discord-selfbot-v13.js 0.0.1-security → 2.5.0

package/src/client/WebhookClient.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const BaseClient = require('./BaseClient');
+const { Error } = require('../errors');
+const Webhook = require('../structures/Webhook');
+
+/**
+ * The webhook client.
+ * @implements {Webhook}
+ * @extends {BaseClient}
+ */
+class WebhookClient extends BaseClient {
+  /**
+   * The data for the webhook client containing either an id and token or just a URL
+   * @typedef {Object} WebhookClientData
+   * @property {Snowflake} [id] The id of the webhook
+   * @property {string} [token] The token of the webhook
+   * @property {string} [url] The full URL for the webhook client
+   */
+
+  /**
+   * @param {WebhookClientData} data The data of the webhook
+   * @param {ClientOptions} [options] Options for the client
+   */
+  constructor(data, options) {
+    super(options);
+    Object.defineProperty(this, 'client', { value: this });
+    let { id, token } = data;
+
+    if ('url' in data) {
+      const url = data.url.match(
+        // eslint-disable-next-line no-useless-escape
+        /^https?:\/\/(?:canary|ptb)?\.?discord\.com\/api\/webhooks(?:\/v[0-9]\d*)?\/([^\/]+)\/([^\/]+)/i,
+      );
+
+      if (!url || url.length <= 1) throw new Error('WEBHOOK_URL_INVALID');
+
+      [, id, token] = url;
+    }
+
+    this.id = id;
+    Object.defineProperty(this, 'token', { value: token, writable: true, configurable: true });
+  }
+
+  // These are here only for documentation purposes - they are implemented by Webhook
+  /* eslint-disable no-empty-function */
+  send() {}
+  sendSlackMessage() {}
+  fetchMessage() {}
+  edit() {}
+  editMessage() {}
+  delete() {}
+  deleteMessage() {}
+  get createdTimestamp() {}
+  get createdAt() {}
+  get url() {}
+}
+
+Webhook.applyToClass(WebhookClient);
+
+module.exports = WebhookClient;

package/src/client/actions/Action.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const { PartialTypes } = require('../../util/Constants');
+
+/*
+
+ABOUT ACTIONS
+
+Actions are similar to WebSocket Packet Handlers, but since introducing
+the REST API methods, in order to prevent rewriting code to handle data,
+"actions" have been introduced. They're basically what Packet Handlers
+used to be but they're strictly for manipulating data and making sure
+that WebSocket events don't clash with REST methods.
+
+*/
+
+class GenericAction {
+  constructor(client) {
+    this.client = client;
+  }
+
+  handle(data) {
+    return data;
+  }
+
+  getPayload(data, manager, id, partialType, cache) {
+    const existing = manager.cache.get(id);
+    if (!existing && this.client.options.partials.includes(partialType)) {
+      return manager._add(data, cache);
+    }
+    return existing;
+  }
+
+  getChannel(data) {
+    const id = data.channel_id ?? data.id;
+    return (
+      data.channel ??
+      this.getPayload(
+        {
+          id,
+          guild_id: data.guild_id,
+          recipients: [data.author ?? data.user ?? { id: data.user_id }],
+        },
+        this.client.channels,
+        id,
+        PartialTypes.CHANNEL,
+      )
+    );
+  }
+
+  getMessage(data, channel, cache) {
+    const id = data.message_id ?? data.id;
+    return (
+      data.message ??
+      this.getPayload(
+        {
+          id,
+          channel_id: channel.id,
+          guild_id: data.guild_id ?? channel.guild?.id,
+        },
+        channel.messages,
+        id,
+        PartialTypes.MESSAGE,
+        cache,
+      )
+    );
+  }
+
+  getReaction(data, message, user) {
+    const id = data.emoji.id ?? decodeURIComponent(data.emoji.name);
+    return this.getPayload(
+      {
+        emoji: data.emoji,
+        count: message.partial ? null : 0,
+        me: user?.id === this.client.user.id,
+      },
+      message.reactions,
+      id,
+      PartialTypes.REACTION,
+    );
+  }
+
+  getMember(data, guild) {
+    return this.getPayload(data, guild.members, data.user.id, PartialTypes.GUILD_MEMBER);
+  }
+
+  getUser(data) {
+    const id = data.user_id;
+    return data.user ?? this.getPayload({ id }, this.client.users, id, PartialTypes.USER);
+  }
+
+  getUserFromMember(data) {
+    if (data.guild_id && data.member?.user) {
+      const guild = this.client.guilds.cache.get(data.guild_id);
+      if (guild) {
+        return guild.members._add(data.member).user;
+      } else {
+        return this.client.users._add(data.member.user);
+      }
+    }
+    return this.getUser(data);
+  }
+
+  getScheduledEvent(data, guild) {
+    const id = data.guild_scheduled_event_id ?? data.id;
+    return this.getPayload(
+      { id, guild_id: data.guild_id ?? guild.id },
+      guild.scheduledEvents,
+      id,
+      PartialTypes.GUILD_SCHEDULED_EVENT,
+    );
+  }
+}
+
+module.exports = GenericAction;

package/src/client/actions/ActionsManager.js

@@ -0,0 +1,72 @@
+'use strict';
+
+class ActionsManager {
+  constructor(client) {
+    this.client = client;
+
+    this.register(require('./ApplicationCommandPermissionsUpdate'));
+    this.register(require('./AutoModerationActionExecution'));
+    this.register(require('./AutoModerationRuleCreate'));
+    this.register(require('./AutoModerationRuleDelete'));
+    this.register(require('./AutoModerationRuleUpdate'));
+    this.register(require('./ChannelCreate'));
+    this.register(require('./ChannelDelete'));
+    this.register(require('./ChannelUpdate'));
+    this.register(require('./GuildAuditLogEntryCreate'));
+    this.register(require('./GuildBanAdd'));
+    this.register(require('./GuildBanRemove'));
+    this.register(require('./GuildChannelsPositionUpdate'));
+    this.register(require('./GuildDelete'));
+    this.register(require('./GuildEmojiCreate'));
+    this.register(require('./GuildEmojiDelete'));
+    this.register(require('./GuildEmojiUpdate'));
+    this.register(require('./GuildEmojisUpdate'));
+    this.register(require('./GuildIntegrationsUpdate'));
+    this.register(require('./GuildMemberRemove'));
+    this.register(require('./GuildMemberUpdate'));
+    this.register(require('./GuildRoleCreate'));
+    this.register(require('./GuildRoleDelete'));
+    this.register(require('./GuildRoleUpdate'));
+    this.register(require('./GuildRolesPositionUpdate'));
+    this.register(require('./GuildScheduledEventCreate'));
+    this.register(require('./GuildScheduledEventDelete'));
+    this.register(require('./GuildScheduledEventUpdate'));
+    this.register(require('./GuildScheduledEventUserAdd'));
+    this.register(require('./GuildScheduledEventUserRemove'));
+    this.register(require('./GuildStickerCreate'));
+    this.register(require('./GuildStickerDelete'));
+    this.register(require('./GuildStickerUpdate'));
+    this.register(require('./GuildStickersUpdate'));
+    this.register(require('./GuildUpdate'));
+    this.register(require('./InteractionCreate'));
+    this.register(require('./InviteCreate'));
+    this.register(require('./InviteDelete'));
+    this.register(require('./MessageCreate'));
+    this.register(require('./MessageDelete'));
+    this.register(require('./MessageDeleteBulk'));
+    this.register(require('./MessageReactionAdd'));
+    this.register(require('./MessageReactionRemove'));
+    this.register(require('./MessageReactionRemoveAll'));
+    this.register(require('./MessageReactionRemoveEmoji'));
+    this.register(require('./MessageUpdate'));
+    this.register(require('./PresenceUpdate'));
+    this.register(require('./StageInstanceCreate'));
+    this.register(require('./StageInstanceDelete'));
+    this.register(require('./StageInstanceUpdate'));
+    this.register(require('./ThreadCreate'));
+    this.register(require('./ThreadDelete'));
+    this.register(require('./ThreadListSync'));
+    this.register(require('./ThreadMemberUpdate'));
+    this.register(require('./ThreadMembersUpdate'));
+    this.register(require('./TypingStart'));
+    this.register(require('./UserUpdate'));
+    this.register(require('./VoiceStateUpdate'));
+    this.register(require('./WebhooksUpdate'));
+  }
+
+  register(Action) {
+    this[Action.name.replace(/Action$/, '')] = new Action(this.client);
+  }
+}
+
+module.exports = ActionsManager;

package/src/client/actions/ApplicationCommandPermissionsUpdate.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+/**
+ * The data received in the {@link Client#event:applicationCommandPermissionsUpdate} event
+ * @typedef {Object} ApplicationCommandPermissionsUpdateData
+ * @property {Snowflake} id The id of the command or global entity that was updated
+ * @property {Snowflake} guildId The id of the guild in which permissions were updated
+ * @property {Snowflake} applicationId The id of the application that owns the command or entity being updated
+ * @property {ApplicationCommandPermissions[]} permissions The updated permissions
+ */
+
+class ApplicationCommandPermissionsUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    /**
+     * Emitted whenever permissions for an application command in a guild were updated.
+     * <warn>This includes permission updates for other applications in addition to the logged in client,
+     * check `data.applicationId` to verify which application the update is for</warn>
+     * @event Client#applicationCommandPermissionsUpdate
+     * @param {ApplicationCommandPermissionsUpdateData} data The updated permissions
+     */
+    client.emit(Events.APPLICATION_COMMAND_PERMISSIONS_UPDATE, {
+      permissions: data.permissions,
+      id: data.id,
+      guildId: data.guild_id,
+      applicationId: data.application_id,
+    });
+  }
+}
+
+module.exports = ApplicationCommandPermissionsUpdateAction;

package/src/client/actions/AutoModerationActionExecution.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const Action = require('./Action');
+const AutoModerationActionExecution = require('../../structures/AutoModerationActionExecution');
+const { Events } = require('../../util/Constants');
+
+class AutoModerationActionExecutionAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      /**
+       * Emitted whenever an auto moderation rule is triggered.
+       * <info>This event requires the {@link Permissions.FLAGS.MANAGE_GUILD} permission.</info>
+       * @event Client#autoModerationActionExecution
+       * @param {AutoModerationActionExecution} autoModerationActionExecution The data of the execution
+       */
+      client.emit(Events.AUTO_MODERATION_ACTION_EXECUTION, new AutoModerationActionExecution(data, guild));
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationActionExecutionAction;

package/src/client/actions/AutoModerationRuleCreate.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class AutoModerationRuleCreateAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const autoModerationRule = guild.autoModerationRules._add(data);
+
+      /**
+       * Emitted whenever an auto moderation rule is created.
+       * <info>This event requires the {@link Permissions.FLAGS.MANAGE_GUILD} permission.</info>
+       * @event Client#autoModerationRuleCreate
+       * @param {AutoModerationRule} autoModerationRule The created auto moderation rule
+       */
+      client.emit(Events.AUTO_MODERATION_RULE_CREATE, autoModerationRule);
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleCreateAction;

package/src/client/actions/AutoModerationRuleDelete.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class AutoModerationRuleDeleteAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const autoModerationRule = guild.autoModerationRules.cache.get(data.id);
+
+      if (autoModerationRule) {
+        guild.autoModerationRules.cache.delete(autoModerationRule.id);
+
+        /**
+         * Emitted whenever an auto moderation rule is deleted.
+         * <info>This event requires the {@link Permissions.FLAGS.MANAGE_GUILD} permission.</info>
+         * @event Client#autoModerationRuleDelete
+         * @param {AutoModerationRule} autoModerationRule The deleted auto moderation rule
+         */
+        client.emit(Events.AUTO_MODERATION_RULE_DELETE, autoModerationRule);
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleDeleteAction;

package/src/client/actions/AutoModerationRuleUpdate.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class AutoModerationRuleUpdateAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const oldAutoModerationRule = guild.autoModerationRules.cache.get(data.id)?._clone() ?? null;
+      const newAutoModerationRule = guild.autoModerationRules._add(data);
+
+      /**
+       * Emitted whenever an auto moderation rule gets updated.
+       * <info>This event requires the {@link Permissions.FLAGS.MANAGE_GUILD} permission.</info>
+       * @event Client#autoModerationRuleUpdate
+       * @param {?AutoModerationRule} oldAutoModerationRule The auto moderation rule before the update
+       * @param {AutoModerationRule} newAutoModerationRule The auto moderation rule after the update
+       */
+      client.emit(Events.AUTO_MODERATION_RULE_UPDATE, oldAutoModerationRule, newAutoModerationRule);
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleUpdateAction;

package/src/client/actions/ChannelCreate.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ChannelCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const existing = client.channels.cache.has(data.id);
+    const channel = client.channels._add(data);
+    if (!existing && channel) {
+      /**
+       * Emitted whenever a guild channel is created.
+       * @event Client#channelCreate
+       * @param {GuildChannel} channel The channel that was created
+       */
+      client.emit(Events.CHANNEL_CREATE, channel);
+    }
+    return { channel };
+  }
+}
+
+module.exports = ChannelCreateAction;

package/src/client/actions/ChannelDelete.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedChannels } = require('../../structures/Channel');
+const DMChannel = require('../../structures/DMChannel');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class ChannelDeleteAction extends Action {
+  constructor(client) {
+    super(client);
+    this.deleted = new Map();
+  }
+
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.id);
+
+    if (channel) {
+      client.channels._remove(channel.id);
+      deletedChannels.add(channel);
+      if (channel.messages && !(channel instanceof DMChannel)) {
+        for (const message of channel.messages.cache.values()) {
+          deletedMessages.add(message);
+        }
+      }
+      /**
+       * Emitted whenever a channel is deleted.
+       * @event Client#channelDelete
+       * @param {DMChannel|GuildChannel} channel The channel that was deleted
+       */
+      client.emit(Events.CHANNEL_DELETE, channel);
+    }
+
+    return { channel };
+  }
+}
+
+module.exports = ChannelDeleteAction;

package/src/client/actions/ChannelUpdate.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Action = require('./Action');
+const { Channel } = require('../../structures/Channel');
+const { ChannelTypes } = require('../../util/Constants');
+
+class ChannelUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    let channel = client.channels.cache.get(data.id);
+    if (channel) {
+      const old = channel._update(data);
+
+      if (ChannelTypes[channel.type] !== data.type) {
+        const newChannel = Channel.create(this.client, data, channel.guild);
+        for (const [id, message] of channel.messages.cache) newChannel.messages.cache.set(id, message);
+        channel = newChannel;
+        this.client.channels.cache.set(channel.id, channel);
+      }
+
+      return {
+        old,
+        updated: channel,
+      };
+    } else {
+      client.channels._add(data);
+    }
+
+    return {};
+  }
+}
+
+module.exports = ChannelUpdateAction;

package/src/client/actions/GuildAuditLogEntryCreate.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const GuildAuditLogsEntry = require('../../structures/GuildAuditLogs').Entry;
+const { Events } = require('../../util/Constants');
+
+class GuildAuditLogEntryCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let auditLogEntry;
+
+    if (guild) {
+      auditLogEntry = new GuildAuditLogsEntry(guild, data);
+
+      /**
+       * Emitted whenever a guild audit log entry is created.
+       * @event Client#guildAuditLogEntryCreate
+       * @param {GuildAuditLogsEntry} auditLogEntry The entry that was created
+       * @param {Guild} guild The guild where the entry was created
+       */
+      client.emit(Events.GUILD_AUDIT_LOG_ENTRY_CREATE, auditLogEntry, guild);
+    }
+
+    return { auditLogEntry };
+  }
+}
+
+module.exports = GuildAuditLogEntryCreateAction;

package/src/client/actions/GuildBanAdd.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class GuildBanAdd extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    /**
+     * Emitted whenever a member is banned from a guild.
+     * @event Client#guildBanAdd
+     * @param {GuildBan} ban The ban that occurred
+     */
+    if (guild) client.emit(Events.GUILD_BAN_ADD, guild.bans._add(data));
+  }
+}
+
+module.exports = GuildBanAdd;

package/src/client/actions/GuildBanRemove.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const Action = require('./Action');
+const GuildBan = require('../../structures/GuildBan');
+const { Events } = require('../../util/Constants');
+
+class GuildBanRemove extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    /**
+     * Emitted whenever a member is unbanned from a guild.
+     * @event Client#guildBanRemove
+     * @param {GuildBan} ban The ban that was removed
+     */
+    if (guild) {
+      const ban = guild.bans.cache.get(data.user.id) ?? new GuildBan(client, data, guild);
+      guild.bans.cache.delete(ban.user.id);
+      client.emit(Events.GUILD_BAN_REMOVE, ban);
+    }
+  }
+}
+
+module.exports = GuildBanRemove;

package/src/client/actions/GuildChannelsPositionUpdate.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const Action = require('./Action');
+
+class GuildChannelsPositionUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      for (const partialChannel of data.channels) {
+        const channel = guild.channels.cache.get(partialChannel.id);
+        if (channel) channel.rawPosition = partialChannel.position;
+      }
+    }
+
+    return { guild };
+  }
+}
+
+module.exports = GuildChannelsPositionUpdate;

package/src/client/actions/GuildDelete.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const { setTimeout } = require('node:timers');
+const Action = require('./Action');
+const { deletedGuilds } = require('../../structures/Guild');
+const { Events } = require('../../util/Constants');
+
+class GuildDeleteAction extends Action {
+  constructor(client) {
+    super(client);
+    this.deleted = new Map();
+  }
+
+  handle(data) {
+    const client = this.client;
+
+    let guild = client.guilds.cache.get(data.id);
+    if (guild) {
+      if (data.unavailable) {
+        // Guild is unavailable
+        guild.available = false;
+
+        /**
+         * Emitted whenever a guild becomes unavailable, likely due to a server outage.
+         * @event Client#guildUnavailable
+         * @param {Guild} guild The guild that has become unavailable
+         */
+        client.emit(Events.GUILD_UNAVAILABLE, guild);
+
+        // Stops the GuildDelete packet thinking a guild was actually deleted,
+        // handles emitting of event itself
+        return {
+          guild: null,
+        };
+      }
+
+      for (const channel of guild.channels.cache.values()) this.client.channels._remove(channel.id);
+      client.voice.adapters.get(data.id)?.destroy();
+
+      // Delete guild
+      client.guilds.cache.delete(guild.id);
+      deletedGuilds.add(guild);
+
+      /**
+       * Emitted whenever a guild kicks the client or the guild is deleted/left.
+       * @event Client#guildDelete
+       * @param {Guild} guild The guild that was deleted
+       */
+      client.emit(Events.GUILD_DELETE, guild);
+
+      this.deleted.set(guild.id, guild);
+      this.scheduleForDeletion(guild.id);
+    } else {
+      guild = this.deleted.get(data.id) ?? null;
+    }
+
+    return { guild };
+  }
+
+  scheduleForDeletion(id) {
+    setTimeout(() => this.deleted.delete(id), this.client.options.restWsBridgeTimeout).unref();
+  }
+}
+
+module.exports = GuildDeleteAction;

package/src/client/actions/GuildEmojiCreate.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class GuildEmojiCreateAction extends Action {
+  handle(guild, createdEmoji) {
+    const already = guild.emojis.cache.has(createdEmoji.id);
+    const emoji = guild.emojis._add(createdEmoji);
+    /**
+     * Emitted whenever a custom emoji is created in a guild.
+     * @event Client#emojiCreate
+     * @param {GuildEmoji} emoji The emoji that was created
+     */
+    if (!already) this.client.emit(Events.GUILD_EMOJI_CREATE, emoji);
+    return { emoji };
+  }
+}
+
+module.exports = GuildEmojiCreateAction;