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

package/src/client/websocket/handlers/APPLICATION_COMMAND_AUTOCOMPLETE_RESPONSE.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  /**
+   * @typedef {object} AutocompleteResponseChoice
+   * @property {string} name The name of the choice
+   * @property {string} value The value of the choice
+   */
+  /**
+   * @typedef {object} AutocompleteResponse
+   * @property {Snowflake} [nonce] Snowflake of the data
+   * @property {Array<AutocompleteResponseChoice>} [choices] Array of choices
+   */
+  /**
+   * Emitted when receiving a response from Discord
+   * @event Client#applicationCommandAutocompleteResponse
+   * @param {AutocompleteResponse} data Data
+   * @deprecated Test only
+   */
+  client.emit(Events.APPLICATION_COMMAND_AUTOCOMPLETE_RESPONSE, data);
+};

package/src/client/websocket/handlers/APPLICATION_COMMAND_CREATE.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const commandManager = data.guild_id ? client.guilds.cache.get(data.guild_id)?.commands : client.application.commands;
+  if (!commandManager) return;
+
+  const command = commandManager._add(data, data.application_id === client.application.id);
+
+  /**
+   * Emitted when a guild application command is created.
+   * @event Client#applicationCommandCreate
+   * @param {ApplicationCommand} command The command which was created
+   * @deprecated See {@link https://github.com/discord/discord-api-docs/issues/3690 this issue} for more information.
+   */
+  client.emit(Events.APPLICATION_COMMAND_CREATE, command);
+};

package/src/client/websocket/handlers/APPLICATION_COMMAND_DELETE.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const commandManager = data.guild_id ? client.guilds.cache.get(data.guild_id)?.commands : client.application.commands;
+  if (!commandManager) return;
+
+  const isOwn = data.application_id === client.application.id;
+  const command = commandManager._add(data, isOwn);
+  if (isOwn) commandManager.cache.delete(data.id);
+
+  /**
+   * Emitted when a guild application command is deleted.
+   * @event Client#applicationCommandDelete
+   * @param {ApplicationCommand} command The command which was deleted
+   * @deprecated See {@link https://github.com/discord/discord-api-docs/issues/3690 this issue} for more information.
+   */
+  client.emit(Events.APPLICATION_COMMAND_DELETE, command);
+};

package/src/client/websocket/handlers/APPLICATION_COMMAND_PERMISSIONS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ApplicationCommandPermissionsUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/APPLICATION_COMMAND_UPDATE.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const commandManager = data.guild_id ? client.guilds.cache.get(data.guild_id)?.commands : client.application.commands;
+  if (!commandManager) return;
+
+  const oldCommand = commandManager.cache.get(data.id)?._clone() ?? null;
+  const newCommand = commandManager._add(data, data.application_id === client.application.id);
+
+  /**
+   * Emitted when a guild application command is updated.
+   * @event Client#applicationCommandUpdate
+   * @param {?ApplicationCommand} oldCommand The command before the update
+   * @param {ApplicationCommand} newCommand The command after the update
+   * @deprecated See {@link https://github.com/discord/discord-api-docs/issues/3690 this issue} for more information.
+   */
+  client.emit(Events.APPLICATION_COMMAND_UPDATE, oldCommand, newCommand);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_ACTION_EXECUTION.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationActionExecution.handle(packet.d);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/AUTO_MODERATION_RULE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/CALL_CREATE.js

@@ -0,0 +1,14 @@
+'use strict';
+const Call = require('../../../structures/Call');
+const { Events } = require('../../../util/Constants');
+module.exports = (client, packet) => {
+  for (const voice of packet.d.voice_states) {
+    client.actions.VoiceStateUpdate.handle(voice);
+  }
+  /**
+   * Emitted whenever received a call
+   * @event Client#callCreate
+   * @param {Call} call Call
+   */
+  client.emit(Events.CALL_CREATE, new Call(client, packet.d));
+};

package/src/client/websocket/handlers/CALL_DELETE.js

@@ -0,0 +1,11 @@
+'use strict';
+const Call = require('../../../structures/Call');
+const { Events } = require('../../../util/Constants');
+module.exports = (client, packet) => {
+  /**
+   * Emitted whenever delete a call
+   * @event Client#callDelete
+   * @param {Call} call Call
+   */
+  client.emit(Events.CALL_DELETE, new Call(client, packet.d));
+};

package/src/client/websocket/handlers/CALL_UPDATE.js

@@ -0,0 +1,11 @@
+'use strict';
+const Call = require('../../../structures/Call');
+const { Events } = require('../../../util/Constants');
+module.exports = (client, packet) => {
+  /**
+   * Emitted whenever update a call
+   * @event Client#callUpdate
+   * @param {Call} call Call
+   */
+  client.emit(Events.CALL_UPDATE, new Call(client, packet.d));
+};

package/src/client/websocket/handlers/CHANNEL_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/CHANNEL_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/CHANNEL_PINS_UPDATE.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const time = data.last_pin_timestamp ? new Date(data.last_pin_timestamp).getTime() : null;
+
+  if (channel) {
+    // Discord sends null for last_pin_timestamp if the last pinned message was removed
+    channel.lastPinTimestamp = time;
+
+    /**
+     * Emitted whenever the pins of a channel are updated. Due to the nature of the WebSocket event,
+     * not much information can be provided easily here - you need to manually check the pins yourself.
+     * @event Client#channelPinsUpdate
+     * @param {TextBasedChannels} channel The channel that the pins update occurred in
+     * @param {Date} time The time of the pins update
+     */
+    client.emit(Events.CHANNEL_PINS_UPDATE, channel, time);
+  }
+};

package/src/client/websocket/handlers/CHANNEL_RECIPIENT_ADD.js

@@ -0,0 +1,16 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+module.exports = (client, packet) => {
+  /**
+   * Emitted whenever a recipient is added from a group DM.
+   * @event Client#channelRecipientAdd
+   * @param {PartialGroupDMChannel} channel Group DM channel
+   * @param {User} user User
+   */
+  const channel = client.channels.cache.get(packet.d.channel_id);
+  if (!channel) return;
+  if (!channel._recipients) channel._recipients = [];
+  channel._recipients.push(packet.d.user);
+  const user = client.users._add(packet.d.user);
+  client.emit(Events.CHANNEL_RECIPIENT_ADD, channel, user);
+};

package/src/client/websocket/handlers/CHANNEL_RECIPIENT_REMOVE.js

@@ -0,0 +1,16 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+module.exports = (client, packet) => {
+  /**
+   * Emitted whenever a recipient is removed from a group DM.
+   * @event Client#channelRecipientRemove
+   * @param {PartialGroupDMChannel} channel Group DM channel
+   * @param {User} user User
+   */
+  const channel = client.channels.cache.get(packet.d.channel_id);
+  if (!channel) return;
+  if (!channel._recipients) channel._recipients = [];
+  channel._recipients = channel._recipients.filter(r => r !== packet.d.user.id);
+  const user = client.users._add(packet.d.user);
+  client.emit(Events.CHANNEL_RECIPIENT_REMOVE, channel, user);
+};

package/src/client/websocket/handlers/CHANNEL_UPDATE.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a channel is updated - e.g. name change, topic change, channel type change.
+     * @event Client#channelUpdate
+     * @param {DMChannel|GuildChannel} oldChannel The channel before the update
+     * @param {DMChannel|GuildChannel} newChannel The channel after the update
+     */
+    client.emit(Events.CHANNEL_UPDATE, old, updated);
+  }
+};

package/src/client/websocket/handlers/GUILD_APPLICATION_COMMANDS_UPDATE.js

@@ -0,0 +1,11 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  for (const command of data.application_commands) {
+    const user = client.users.cache.get(command.application_id);
+    if (!user || !user.bot) continue;
+    user.application?.commands?._add(command, true);
+  }
+  client.emit(Events.GUILD_APPLICATION_COMMANDS_UPDATE, data);
+};

package/src/client/websocket/handlers/GUILD_AUDIT_LOG_ENTRY_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildAuditLogEntryCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_BAN_ADD.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildBanAdd.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_BAN_REMOVE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildBanRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_CREATE.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { Events, Opcodes, Status } = require('../../../util/Constants');
+
+// Receive messages in large guilds
+const run = (client, guild) => {
+  if (!guild.large) return;
+  client.ws.broadcast({
+    op: Opcodes.GUILD_SUBSCRIPTIONS,
+    d: {
+      guild_id: guild.id,
+      typing: true,
+      threads: false,
+      activities: true,
+      thread_member_lists: [],
+      members: [],
+      channels: {
+        // [guild.channels.cache.first().id]: [[0, 99]],
+      },
+    },
+  });
+};
+
+module.exports = (client, { d: data }, shard) => {
+  let guild = client.guilds.cache.get(data.id);
+  if (guild) {
+    if (!guild.available && !data.unavailable) {
+      // A newly available guild
+      guild._patch(data);
+      run(client, guild);
+
+      /**
+       * Emitted whenever a guild becomes available.
+       * @event Client#guildAvailable
+       * @param {Guild} guild The guild that became available
+       */
+      client.emit(Events.GUILD_AVAILABLE, guild);
+    }
+  } else {
+    // A new guild
+    data.shardId = shard.id;
+    guild = client.guilds._add(data);
+    if (client.ws.status === Status.READY) {
+      /**
+       * Emitted whenever the client joins a guild.
+       * @event Client#guildCreate
+       * @param {Guild} guild The created guild
+       */
+      client.emit(Events.GUILD_CREATE, guild);
+      run(client, guild);
+    }
+  }
+};

package/src/client/websocket/handlers/GUILD_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_EMOJIS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildEmojisUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_INTEGRATIONS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildIntegrationsUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_MEMBERS_CHUNK.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+  const members = new Collection();
+
+  for (const member of data.members) members.set(member.user.id, guild.members._add(member));
+  if (data.presences) {
+    for (const presence of data.presences) guild.presences._add(Object.assign(presence, { guild }));
+  }
+
+  /**
+   * Represents the properties of a guild members chunk
+   * @typedef {Object} GuildMembersChunk
+   * @property {number} index Index of the received chunk
+   * @property {number} count Number of chunks the client should receive
+   * @property {?string} nonce Nonce for this chunk
+   * @property {Array<*>} notFound An array of whatever could not be found
+   * when using {@link Opcodes.REQUEST_GUILD_MEMBERS}
+   */
+
+  /**
+   * Emitted whenever a chunk of guild members is received (all members come from the same guild).
+   * @event Client#guildMembersChunk
+   * @param {Collection<Snowflake, GuildMember>} members The members in the chunk
+   * @param {Guild} guild The guild related to the member chunk
+   * @param {GuildMembersChunk} chunk Properties of the received chunk
+   */
+  client.emit(Events.GUILD_MEMBERS_CHUNK, members, guild, {
+    count: data.chunk_count,
+    index: data.chunk_index,
+    nonce: data.nonce,
+    notFound: data.not_found,
+  });
+};

package/src/client/websocket/handlers/GUILD_MEMBER_ADD.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { Events, Status } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }, shard) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (guild) {
+    guild.memberCount++;
+    const member = guild.members._add(data);
+    if (shard.status === Status.READY) {
+      /**
+       * Emitted whenever a user joins a guild.
+       * @event Client#guildMemberAdd
+       * @param {GuildMember} member The member that has joined a guild
+       * @deprecated See {@link https://github.com/aiko-chan-ai/discord.js-selfbot-v13/issues/197 this issue} for more information.
+       */
+      client.emit(Events.GUILD_MEMBER_ADD, member);
+    }
+  }
+};

package/src/client/websocket/handlers/GUILD_MEMBER_LIST_UPDATE.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+  const members = new Collection();
+  // Get Member from side Discord Channel (online counting if large server)
+  for (const object of data.ops) {
+    switch (object.op) {
+      case 'SYNC': {
+        for (const member_ of object.items) {
+          const member = member_.member;
+          if (!member) continue;
+          members.set(member.user.id, guild.members._add(member));
+          if (member.presence) {
+            guild.presences._add(Object.assign(member.presence, { guild }));
+          }
+        }
+        break;
+      }
+      case 'INVALIDATE': {
+        client.emit(
+          Events.DEBUG,
+          `Invalidate [${object.range[0]}, ${object.range[1]}], Fetching GuildId: ${data.guild_id}`,
+        );
+        break;
+      }
+      case 'UPDATE':
+      case 'INSERT': {
+        const member = object.item.member;
+        if (!member) continue;
+        members.set(member.user.id, guild.members._add(member));
+        if (member.presence) {
+          guild.presences._add(Object.assign(member.presence, { guild }));
+        }
+        break;
+      }
+      case 'DELETE': {
+        break;
+      }
+    }
+  }
+  /**
+   * Emitted whenever a guild member list (sidebar) is updated.
+   * @event Client#guildMemberListUpdate
+   * @param {Collection<Snowflake, GuildMember>} members Members that were updated
+   * @param {Guild} guild Guild
+   * @param {string} type Type of update (INVALIDATE | UPDATE | INSERT | DELETE | SYNC)
+   * @param {data} raw Raw data
+   */
+  client.emit(Events.GUILD_MEMBER_LIST_UPDATE, members, guild, data.ops[0].op, data);
+};

package/src/client/websocket/handlers/GUILD_MEMBER_REMOVE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet, shard) => {
+  client.actions.GuildMemberRemove.handle(packet.d, shard);
+};

package/src/client/websocket/handlers/GUILD_MEMBER_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet, shard) => {
+  client.actions.GuildMemberUpdate.handle(packet.d, shard);
+};

package/src/client/websocket/handlers/GUILD_ROLE_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_ROLE_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_ROLE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventCreate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventDelete.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_USER_ADD.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventUserAdd.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_SCHEDULED_EVENT_USER_REMOVE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildScheduledEventUserRemove.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_STICKERS_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildStickersUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/GUILD_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/INTERACTION_CREATE.js

@@ -0,0 +1,16 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+/**
+ * @typedef {Object} InteractionResponseBody
+ * @property {Snowflake} id Interaction ID
+ * @property {Snowflake} nonce nonce in POST /interactions
+ */
+
+module.exports = (client, { d: data }) => {
+  if (client.user.bot) {
+    client.actions.InteractionCreate.handle(data);
+  } else {
+    client.emit(Events.INTERACTION_CREATE, data);
+  }
+};

package/src/client/websocket/handlers/INTERACTION_FAILURE.js

@@ -0,0 +1,18 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  /**
+   * Emitted whenever client user send interaction and error
+   * @event Client#interactionFailure
+   * @param {InteractionResponseBody} data data
+   */
+  client.emit(Events.INTERACTION_FAILURE, data);
+  client.emit('interactionResponse', {
+    status: false,
+    metadata: client._interactionCache.get(data.nonce),
+    error: 'No response from bot',
+  });
+  // Delete cache
+  client._interactionCache.delete(data.nonce);
+};

package/src/client/websocket/handlers/INTERACTION_MODAL_CREATE.js

@@ -0,0 +1,11 @@
+'use strict';
+const Modal = require('../../../structures/Modal');
+const { Events } = require('../../../util/Constants');
+module.exports = (client, { d: data }) => {
+  /**
+   * Emitted whenever client user receive interaction.showModal()
+   * @event Client#interactionModalCreate
+   * @param {Modal} modal The modal (extended)
+   */
+  client.emit(Events.INTERACTION_MODAL_CREATE, new Modal(data, client));
+};

package/src/client/websocket/handlers/INTERACTION_SUCCESS.js

@@ -0,0 +1,30 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  /**
+   * Emitted whenever client user send interaction and success
+   * @event Client#interactionSuccess
+   * @param {InteractionResponseBody} data data
+   */
+  client.emit(Events.INTERACTION_SUCCESS, data);
+  // Get channel data
+  const cache = client._interactionCache.get(data.nonce);
+  if (!cache) return;
+  const channel = cache.guildId
+    ? client.guilds.cache.get(cache.guildId)?.channels.cache.get(cache.channelId)
+    : client.channels.cache.get(cache.channelId);
+  // Set data
+  const interaction = {
+    ...cache,
+    ...data,
+  };
+  const data_ = channel.interactions._add(interaction);
+  client.emit('interactionResponse', {
+    status: true,
+    metadata: data_,
+    error: 'Success',
+  });
+  // Delete cache
+  // client._interactionCache.delete(data.nonce);
+};