djs-selfbot-v13 3.1.5 → 3.1.7

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

@@ -1,16 +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) {
-    if (!channel._recipients) channel._recipients = [];
-    channel._recipients = channel._recipients.filter(u => u.id !== packet.d.user.id);
-    /**
-     * Emitted whenever a recipient is removed from a group DM.
-     * @event Client#channelRecipientRemove
-     * @param {GroupDMChannel} channel Group DM channel
-     * @param {User} user User
-     */
-    client.emit(Events.CHANNEL_RECIPIENT_REMOVE, channel, client.users._add(packet.d.user));
-  }
+  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/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_CREATE.js

@@ -28,13 +28,6 @@ module.exports = (client, { d: data }, shard) => {
       // 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

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

@@ -12,7 +12,7 @@ module.exports = (client, { d: data }, shard) => {
        * 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/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

@@ -1,7 +1,6 @@
 'use strict';
 const Modal = require('../../../structures/Modal');
 const { Events } = require('../../../util/Constants');
-
 module.exports = (client, { d: data }) => {
   /**
    * Emitted whenever client user receive interaction.showModal()

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);
+};

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

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  /**
+   * Emitted whenever message is acknowledged (mark read / unread)
+   * @event Client#messageAck
+   * @param {TextChannel} channel Channel
+   * @param {Snowflake} message_id Message ID
+   * @param {boolean} isRead Whether the message is read
+   * @param {Object} raw Raw data
+   */
+  client.emit(Events.MESSAGE_ACK, channel, data.message_id, !data.manual, data);
+};

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

@@ -1,14 +1,105 @@
 'use strict';
 
-const USER_REQUIRED_ACTION = require('./USER_REQUIRED_ACTION_UPDATE');
-const { Opcodes } = require('../../../util/Constants');
-
 let ClientUser;
+const { VoiceConnection } = require('@discordjs/voice');
+const chalk = require('chalk');
+const { Events, Opcodes } = require('../../../util/Constants');
+const { VoiceConnection: VoiceConnection_patch } = require('../../../util/Voice');
+let firstReady = false;
+
+function patchVoice(client) {
+  try {
+    /* eslint-disable */
+    VoiceConnection.prototype.configureNetworking = VoiceConnection_patch.prototype.configureNetworking;
+    client.emit(
+      'debug',
+      `${chalk.greenBright('[OK]')} Patched ${chalk.cyanBright(
+        'VoiceConnection.prototype.configureNetworking',
+      )} [${chalk.bgMagentaBright('@discordjs/voice')} - ${chalk.redBright('v0.16.0')}]`,
+    );
+    /* eslint-enable */
+  } catch (e) {
+    client.emit(
+      'debug',
+      `${chalk.redBright('[Fail]')} Patched ${chalk.cyanBright(
+        'VoiceConnection.prototype.configureNetworking',
+      )} [${chalk.bgMagentaBright('@discordjs/voice')} - ${chalk.redBright('v0.16.0')}]\n${e.stack}`,
+    );
+    client.emit(
+      Events.ERROR,
+      `${chalk.redBright('[Fail]')} Patched ${chalk.cyanBright(
+        'VoiceConnection.prototype.configureNetworking',
+      )} [${chalk.bgMagentaBright('@discordjs/voice')} - ${chalk.redBright('v0.16.0')}]`,
+    );
+    client.emit(
+      Events.ERROR,
+      `${chalk.redBright('[Error]')} Please install ${chalk.bgMagentaBright(
+        '@discordjs/voice',
+      )} version ${chalk.redBright('v0.16.0')}`,
+    );
+  }
+}
+
+module.exports = async (client, { d: data }, shard) => {
+  if (!firstReady) {
+    if (client.options.checkUpdate) {
+      client.once('update', (currentVersion, newVersion) => {
+        if (!newVersion) {
+          console.log(`
+      ${chalk.redBright('[WARNING]')} Cannot check new djs-selfbot-v13 version.
+      Current: ${chalk.blueBright(currentVersion)}
+  
+      If you don't want to show this message, set ${chalk.cyanBright('checkUpdate')} to false
+  
+      const client = new Client({
+          checkUpdate: false,
+      });
+  
+      and using event update
+      https://discordjs-self-v13.netlify.app/#/docs/docs/main/class/Client?scrollTo=e-update\n`);
+        } else if (currentVersion !== newVersion && !currentVersion.includes('-')) {
+          console.log(`
+      ${chalk.yellowBright('[WARNING]')} New djs-selfbot-v13 version.
+      Current: ${chalk.redBright(currentVersion)} => Latest: ${chalk.greenBright(newVersion)}
+  
+      If you don't want to show this message, set ${chalk.cyanBright('checkUpdate')} to false
+  
+      const client = new Client({
+          checkUpdate: false,
+      });
+  
+      and using event update
+      https://discordjs-self-v13.netlify.app/#/docs/docs/main/class/Client?scrollTo=e-update\n`);
+        } else {
+          console.log(
+            `
+      ${chalk.greenBright('[OK]')} djs-selfbot-v13 is up to date. Current: ${chalk.blueBright(currentVersion)}
+  
+      If you don't want to show this message, set ${chalk.cyanBright('checkUpdate')} to false
+  
+      const client = new Client({
+          checkUpdate: false,
+      });
+  
+      and using event update
+      https://discordjs-self-v13.netlify.app/#/docs/docs/main/class/Client?scrollTo=e-update\n`,
+          );
+        }
+      });
+      client.checkUpdate();
+    }
 
-module.exports = (client, { d: data }, shard) => {
-  // Check
-  USER_REQUIRED_ACTION(client, { d: data });
+    if (client.options.patchVoice) {
+      patchVoice(client);
+    }
+
+    if (client.options.syncStatus) {
+      client.customStatusAuto(client);
+    }
+    firstReady = true;
+  }
 
+  client.session_id = data.session_id;
   if (client.user) {
     client.user._patch(data.user);
   } else {
@@ -17,8 +108,31 @@ module.exports = (client, { d: data }, shard) => {
     client.users.cache.set(client.user.id, client.user);
   }
 
+  client.settings._patch(data.user_settings);
+
+  client.user.connectedAccounts = data.connected_accounts ?? [];
+
+  client.relationships._setup(data.relationships);
+
+  client.user._patchNote(data.notes);
+
+  const syncTime = Date.now();
   for (const private_channel of data.private_channels) {
-    client.channels._add(private_channel);
+    const channel = client.channels._add(private_channel);
+    // Rate limit warning
+    if (client.options.DMSync) {
+      client.ws.broadcast({
+        op: Opcodes.DM_UPDATE,
+        d: {
+          channel_id: channel.id,
+        },
+      });
+    }
+  }
+  if (client.options.DMSync) {
+    console.warn(
+      `Gateway Rate Limit Warning: Sending ${data.private_channels.length} Requests / ${Date.now() - syncTime || 1} ms`,
+    );
   }
 
   for (const guild of data.guilds) {
@@ -26,55 +140,31 @@ module.exports = (client, { d: data }, shard) => {
     client.guilds._add(guild);
   }
 
-  const largeGuilds = data.guilds.filter(g => g.large);
-  client.emit('debug', `[READY] Received ${data.guilds.length} guilds, ${largeGuilds.length} large guilds`);
-
-  // User Notes
-  client.notes._reload(data.notes);
-
-  // Relationship
-  client.relationships._setup(data.relationships);
-
-  // ClientSetting
-  client.settings._patch(data.user_settings);
-
-  // GuildSetting
   for (const gSetting of Array.isArray(data.user_guild_settings) ? data.user_guild_settings : []) {
     const guild = client.guilds.cache.get(gSetting.guild_id);
     if (guild) guild.settings._patch(gSetting);
   }
-  // Todo: data.auth_session_id_hash
 
-  if (largeGuilds.length) {
+  const largeGuilds = data.guilds.filter(g => g.large);
+
+  client.emit('debug', `[READY] Received ${data.guilds.length} guilds, ${largeGuilds.length} large guilds`);
+
+  // Receive messages in large guilds
+  for (const guild of largeGuilds) {
+    await client.sleep(client.options.messageCreateEventGuildTimeout);
     client.ws.broadcast({
-      op: Opcodes.GUILD_SUBSCRIPTIONS_BULK,
+      op: Opcodes.GUILD_SUBSCRIPTIONS,
       d: {
-        subscriptions: largeGuilds.reduce((accumulator, guild) => {
-          accumulator[guild.id] = {
-            typing: true,
-            threads: true,
-            activities: true,
-            member_updates: true,
-            thread_member_lists: [],
-            members: [],
-            channels: {},
-          };
-          return accumulator;
-        }, {}),
+        guild_id: guild.id,
+        typing: true,
+        threads: true,
+        activities: true,
+        thread_member_lists: [],
+        members: [],
+        channels: {},
       },
     });
   }
 
-  Promise.all(
-    data.private_channels.map(async (c, index) => {
-      if (client.options.DMChannelVoiceStatusSync < 1) return;
-      client.ws.broadcast({
-        op: Opcodes.DM_UPDATE,
-        d: {
-          channel_id: c.id,
-        },
-      });
-      await client.sleep(client.options.DMChannelVoiceStatusSync * index);
-    }),
-  ).then(() => shard.checkReady());
+  shard.checkReady();
 };

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

@@ -1,19 +1,17 @@
 'use strict';
 
-const { Events } = require('../../../util/Constants');
+const { Events, RelationshipTypes } = require('../../../util/Constants');
 
 module.exports = (client, { d: data }) => {
   if (data.user) {
     client.users._add(data.user);
   }
   client.relationships.cache.set(data.id, data.type);
-  client.relationships.friendNicknames.set(data.id, data.nickname);
-  client.relationships.sinceCache.set(data.id, new Date(data.since || 0));
   /**
-   * Emitted when a relationship is created, relevant to the current user.
+   * Emitted whenever a relationship is updated.
    * @event Client#relationshipAdd
-   * @param {Snowflake} user Target userId
-   * @param {boolean} shouldNotify Whether the client should notify the user of this relationship's creation
+   * @param {Snowflake} user The userID that was updated
+   * @param {RelationshipTypes} type The new relationship type
    */
-  client.emit(Events.RELATIONSHIP_ADD, data.id, Boolean(data.should_notify));
+  client.emit(Events.RELATIONSHIP_ADD, data.id, RelationshipTypes[data.type]);
 };

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

@@ -1,17 +1,15 @@
 'use strict';
 
-const { Events } = require('../../../util/Constants');
+const { Events, RelationshipTypes } = require('../../../util/Constants');
 
 module.exports = (client, { d: data }) => {
   client.relationships.cache.delete(data.id);
-  client.relationships.friendNicknames.delete(data.id);
-  client.relationships.sinceCache.delete(data.id);
+  client.user.friendNicknames.delete(data.id);
   /**
-   * Emitted when a relationship is removed, relevant to the current user.
+   * Emitted whenever a relationship is delete.
    * @event Client#relationshipRemove
    * @param {Snowflake} user The userID that was updated
    * @param {RelationshipTypes} type The type of the old relationship
-   * @param {string | null} nickname The nickname of the user in this relationship (1-32 characters)
    */
-  client.emit(Events.RELATIONSHIP_REMOVE, data.id, data.type, data.nickname);
+  client.emit(Events.RELATIONSHIP_REMOVE, data.id, RelationshipTypes[data.type]);
 };

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

@@ -1,41 +1,18 @@
 'use strict';
 
-const { Events } = require('../../../util/Constants');
+const { Events, RelationshipTypes } = require('../../../util/Constants');
 
 module.exports = (client, { d: data }) => {
+  client.relationships.cache.set(data.id, data.type);
   /**
-   * @typedef {Object} RelationshipUpdateObject
-   * @property {RelationshipTypes} type The type of relationship
-   * @property {Date} since When the user requested a relationship
-   * @property {string | null} nickname The nickname of the user in this relationship (1-32 characters)
-   */
-  /**
-   * Emitted when a relationship is updated, relevant to the current user (e.g. friend nickname changed).
-   * <info>This is not sent when the type of a relationship changes; see {@link Client#relationshipAdd} and {@link Client#relationshipRemove} for that.</info>
+   * Emitted whenever a relationship is updated.
    * @event Client#relationshipUpdate
    * @param {Snowflake} user The userID that was updated
-   * @param {RelationshipUpdateObject} oldData Old data
-   * @param {RelationshipUpdateObject} newData New data
+   * @param {RelationshipTypes} type The new relationship type
+   * @param {Object} data The raw data
    */
-  const oldType = client.relationships.cache.get(data.id);
-  const oldSince = client.relationships.sinceCache.get(data.id);
-  const oldNickname = client.relationships.friendNicknames.get(data.id);
-  // Update
-  if (data.type) client.relationships.cache.set(data.id, data.type);
-  if (data.nickname) client.relationships.friendNicknames.set(data.id, data.nickname);
-  if (data.since) client.relationships.sinceCache.set(data.id, new Date(data.since || 0));
-  client.emit(
-    Events.RELATIONSHIP_UPDATE,
-    data.id,
-    {
-      type: oldType,
-      nickname: oldNickname,
-      since: oldSince,
-    },
-    {
-      type: data.type,
-      nickname: data.nickname,
-      since: new Date(data.since || 0),
-    },
-  );
+  if ('nickname' in data) {
+    client.user.friendNicknames.set(data.id, data.nickname);
+  }
+  client.emit(Events.RELATIONSHIP_UPDATE, data.id, RelationshipTypes[data.type], data);
 };

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

@@ -1,6 +1,12 @@
 'use strict';
-
+const { Events } = require('../../../util/Constants');
 module.exports = (client, { d: data }) => {
   const guild = client.guilds.cache.get(data.guild_id);
-  if (guild) guild?.settings._patch(data);
+  guild?.settings._patch(data);
+  /**
+   * Emitted whenever guild settings are updated
+   * @event Client#userGuildSettingsUpdate
+   * @param {Guild} guild Guild
+   */
+  return client.emit(Events.USER_GUILD_SETTINGS_UPDATE, guild);
 };

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

@@ -1,5 +1,5 @@
 'use strict';
 
 module.exports = (client, { d: data }) => {
-  client.notes.cache.set(data.id, data.note);
+  client.user.notes.set(data.id, data.note);
 };

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

@@ -1,5 +1,9 @@
 'use strict';
-
+const { Events } = require('../../../util/Constants');
 module.exports = (client, { d: data }) => {
   client.settings._patch(data);
+  if (('status' in data || 'custom_status' in data) && client.options.syncStatus) {
+    client.customStatusAuto(client);
+  }
+  return client.emit(Events.USER_SETTINGS_UPDATE, data);
 };