djs-selfbot-v13 3.7.29 → 3.7.32

package/src/managers/backup/create.js

@@ -0,0 +1,167 @@
+'use strict';
+
+const {
+  fetchChannelPermissions,
+  fetchTextChannelData,
+  fetchVoiceChannelData,
+  fetchBuffer,
+} = require('./util');
+
+/**
+ * Returns banned members of the guild
+ * @param {import('../../structures/Guild').Guild} guild
+ * @returns {Promise<Object[]>}
+ */
+async function getBans(guild) {
+  const bans = [];
+  const cases = await guild.bans.fetch();
+
+  cases.forEach(ban => {
+    bans.push({
+      id: ban.user.id,
+      reason: ban.reason,
+    });
+  });
+
+  return bans;
+}
+
+/**
+ * Returns members of the guild
+ * @param {import('../../structures/Guild').Guild} guild
+ * @returns {Promise<Object[]>}
+ */
+async function getMembers(guild) {
+  const members = [];
+
+  guild.members.cache.forEach(member => {
+    members.push({
+      userId: member.user.id,
+      username: member.user.username,
+      discriminator: member.user.discriminator,
+      avatarUrl: member.user.avatarURL(),
+      joinedTimestamp: member.joinedTimestamp,
+      roles: member.roles.cache.map(role => role.id),
+      bot: member.user.bot,
+    });
+  });
+
+  return members;
+}
+
+/**
+ * Returns roles of the guild
+ * @param {import('../../structures/Guild').Guild} guild
+ * @returns {Promise<Object[]>}
+ */
+async function getRoles(guild) {
+  const roles = [];
+
+  guild.roles.cache
+    .filter(role => !role.managed)
+    .sort((a, b) => b.position - a.position)
+    .forEach(role => {
+      roles.push({
+        oldId: role.id,
+        name: role.name,
+        color: role.hexColor,
+        hoist: role.hoist,
+        permissions: role.permissions.bitfield.toString(),
+        mentionable: role.mentionable,
+        position: role.position,
+        isEveryone: guild.id === role.id,
+      });
+    });
+
+  return roles;
+}
+
+/**
+ * Returns emojis of the guild
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} options
+ * @returns {Promise<Object[]>}
+ */
+async function getEmojis(guild, options) {
+  const emojis = [];
+
+  for (const emoji of guild.emojis.cache.values()) {
+    const emojiData = { name: emoji.name };
+
+    if (options.saveImages === 'base64') {
+      emojiData.base64 = (await fetchBuffer(emoji.url)).toString('base64');
+    } else {
+      emojiData.url = emoji.url;
+    }
+
+    emojis.push(emojiData);
+  }
+
+  return emojis;
+}
+
+/**
+ * Fetch channel data based on type
+ * @param {import('../../structures/GuildChannel')} channel
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+async function fetchAnyChannelData(channel, options) {
+  if (['GUILD_TEXT', 'GUILD_NEWS'].includes(channel.type)) {
+    return fetchTextChannelData(channel, options);
+  }
+
+  return fetchVoiceChannelData(channel);
+}
+
+/**
+ * Returns channels of the guild
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+async function getChannels(guild, options) {
+  const allChannels = guild.channels.cache;
+
+  const categories = allChannels
+    .filter(ch => ch.type === 'GUILD_CATEGORY')
+    .sort((a, b) => a.position - b.position);
+
+  const categoryDataPromises = categories.map(async category => {
+    const children = allChannels
+      .filter(c => c.parentId === category.id)
+      .sort((a, b) => a.position - b.position);
+
+    const childrenData = await Promise.all(children.map(child => fetchAnyChannelData(child, options)));
+
+    return {
+      name: category.name,
+      permissions: fetchChannelPermissions(category),
+      children: childrenData,
+    };
+  });
+
+  const others = allChannels
+    .filter(
+      ch => !ch.parent && ch.type !== 'GUILD_CATEGORY' && !ch.isThread?.() && ch.type !== 'GUILD_STORE',
+    )
+    .sort((a, b) => a.position - b.position);
+
+  const [categoriesResult, othersResult] = await Promise.all([
+    Promise.all(categoryDataPromises),
+    Promise.all(others.map(ch => fetchAnyChannelData(ch, options))),
+  ]);
+
+  return {
+    categories: categoriesResult,
+    others: othersResult,
+  };
+}
+
+module.exports = {
+  getBans,
+  getMembers,
+  getRoles,
+  getEmojis,
+  getChannels,
+};

package/src/managers/backup/index.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const SnowflakeUtil = require('../../util/SnowflakeUtil');
+const createMaster = require('./create');
+const loadMaster = require('./load');
+const { clearGuild, fetchBuffer } = require('./util');
+
+/**
+ * Creates a guild backup
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} [options] Backup options
+ * @returns {Promise<Object>}
+ */
+async function create(guild, options = {}) {
+  const normalizedOptions = {
+    backupID: null,
+    maxMessagesPerChannel: 10,
+    doNotBackup: ['bans', 'emojis'],
+    backupMembers: false,
+    saveImages: '',
+    ...options,
+    backupID: options.backupID ?? options.backupId ?? null,
+  };
+
+  const backupData = {
+    name: guild.name,
+    verificationLevel: guild.verificationLevel,
+    explicitContentFilter: guild.explicitContentFilter,
+    defaultMessageNotifications: guild.defaultMessageNotifications,
+    afk: guild.afkChannel ? { name: guild.afkChannel.name, timeout: guild.afkTimeout } : null,
+    widget: {
+      enabled: guild.widgetEnabled,
+      channel: guild.widgetChannel ? guild.widgetChannel.name : null,
+    },
+    community: {
+      enabled: guild.features.includes('COMMUNITY'),
+      systemChannelFlags: guild.systemChannelFlags ? guild.systemChannelFlags.bitfield : null,
+      systemChannelId: guild.systemChannelId,
+      rulesChannelId: guild.rulesChannelId,
+      publicUpdatesChannelId: guild.publicUpdatesChannelId,
+      safetyAlertsChannelId: guild.safetyAlertsChannelId || null,
+    },
+    channels: { categories: [], others: [] },
+    roles: [],
+    bans: [],
+    emojis: [],
+    members: [],
+    createdTimestamp: Date.now(),
+    guildID: guild.id,
+    id: normalizedOptions.backupID ?? SnowflakeUtil.generate(Date.now()),
+  };
+
+  if (guild.iconURL()) {
+    if (normalizedOptions.saveImages === 'base64') {
+      backupData.iconBase64 = (await fetchBuffer(guild.iconURL({ dynamic: true }))).toString('base64');
+    }
+    backupData.iconURL = guild.iconURL({ dynamic: true });
+  }
+
+  if (guild.splashURL()) {
+    if (normalizedOptions.saveImages === 'base64') {
+      backupData.splashBase64 = (await fetchBuffer(guild.splashURL())).toString('base64');
+    }
+    backupData.splashURL = guild.splashURL();
+  }
+
+  if (guild.bannerURL()) {
+    if (normalizedOptions.saveImages === 'base64') {
+      backupData.bannerBase64 = (await fetchBuffer(guild.bannerURL())).toString('base64');
+    }
+    backupData.bannerURL = guild.bannerURL();
+  }
+
+  if (normalizedOptions.backupMembers) {
+    backupData.members = await createMaster.getMembers(guild);
+  }
+
+  if (!normalizedOptions.doNotBackup.includes('bans')) {
+    backupData.bans = await createMaster.getBans(guild);
+  }
+
+  if (!normalizedOptions.doNotBackup.includes('roles')) {
+    backupData.roles = await createMaster.getRoles(guild);
+  }
+
+  if (!normalizedOptions.doNotBackup.includes('emojis')) {
+    backupData.emojis = await createMaster.getEmojis(guild, normalizedOptions);
+  }
+
+  if (!normalizedOptions.doNotBackup.includes('channels')) {
+    backupData.channels = await createMaster.getChannels(guild, normalizedOptions);
+  }
+
+  return backupData;
+}
+
+/**
+ * Loads a backup into a guild
+ * @param {Object} backupData
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} [options] Load options
+ * @returns {Promise<Object>}
+ */
+async function load(backupData, guild, options = {}) {
+  if (!guild) throw new Error('Invalid guild');
+
+  const normalizedOptions = {
+    clearGuildBeforeRestore: true,
+    maxMessagesPerChannel: 10,
+    ...options,
+  };
+
+  if (normalizedOptions.clearGuildBeforeRestore) {
+    await clearGuild(guild);
+  }
+
+  await Promise.all([loadMaster.loadConfig(guild, backupData), loadMaster.loadRoles(guild, backupData)]);
+  await new Promise(resolve => setTimeout(resolve, 3000));
+  await loadMaster.loadChannels(guild, backupData, normalizedOptions);
+
+  const restorePromises = [
+    loadMaster.loadAFK(guild, backupData),
+    loadMaster.loadEmbedChannel(guild, backupData),
+  ];
+
+  if (!normalizedOptions.doNotBackup?.includes('emojis')) {
+    restorePromises.push(loadMaster.loadEmojis(guild, backupData));
+  }
+
+  if (!normalizedOptions.doNotBackup?.includes('bans')) {
+    restorePromises.push(loadMaster.loadBans(guild, backupData));
+  }
+
+  await Promise.all(restorePromises);
+  await loadMaster.loadCommunity(guild, backupData);
+  await loadMaster.loadRoleChannelPermissions(guild, backupData);
+
+  return backupData;
+}
+
+module.exports = {
+  create,
+  load,
+};

package/src/managers/backup/load.js

@@ -0,0 +1,293 @@
+'use strict';
+
+const Permissions = require('../../util/Permissions');
+const { loadCategory, loadChannel } = require('./util');
+
+/**
+ * Restores the guild configuration
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadConfig(guild, backupData) {
+  const configPromises = [];
+
+  if (backupData.name) configPromises.push(guild.setName(backupData.name));
+  if (backupData.iconBase64) {
+    configPromises.push(guild.setIcon(Buffer.from(backupData.iconBase64, 'base64')));
+  } else if (backupData.iconURL) {
+    configPromises.push(guild.setIcon(backupData.iconURL));
+  }
+  if (backupData.splashBase64) {
+    configPromises.push(guild.setSplash(Buffer.from(backupData.splashBase64, 'base64')));
+  } else if (backupData.splashURL) {
+    configPromises.push(guild.setSplash(backupData.splashURL));
+  }
+  if (backupData.bannerBase64) {
+    configPromises.push(guild.setBanner(Buffer.from(backupData.bannerBase64, 'base64')));
+  } else if (backupData.bannerURL) {
+    configPromises.push(guild.setBanner(backupData.bannerURL));
+  }
+  if (backupData.verificationLevel) {
+    configPromises.push(guild.setVerificationLevel(backupData.verificationLevel));
+  }
+  if (backupData.defaultMessageNotifications) {
+    configPromises.push(guild.setDefaultMessageNotifications(backupData.defaultMessageNotifications));
+  }
+
+  const changeableExplicitLevel = guild.features.includes('COMMUNITY');
+  if (backupData.explicitContentFilter && changeableExplicitLevel) {
+    configPromises.push(guild.setExplicitContentFilter(backupData.explicitContentFilter));
+  }
+
+  await Promise.all(configPromises);
+}
+
+/**
+ * Restore the guild roles
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadRoles(guild, backupData) {
+  const rolePromises = [];
+
+  backupData.roles.forEach(roleData => {
+    if (roleData.isEveryone) {
+      rolePromises.push(
+        guild.roles.cache.get(guild.id).edit({
+          name: roleData.name,
+          colors: { primaryColor: roleData.color },
+          permissions: BigInt(roleData.permissions),
+          mentionable: roleData.mentionable,
+        }),
+      );
+    } else {
+      rolePromises.push(
+        guild.roles.create({
+          name: roleData.name,
+          colors: { primaryColor: roleData.color },
+          hoist: roleData.hoist,
+          permissions: BigInt(roleData.permissions),
+          mentionable: roleData.mentionable,
+        }),
+      );
+    }
+  });
+
+  await Promise.all(rolePromises);
+}
+
+/**
+ * Restore the guild channels
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function loadChannels(guild, backupData, options) {
+  const loadChannelPromises = [];
+
+  backupData.channels.categories.forEach(categoryData => {
+    if (!categoryData.name) return;
+
+    loadChannelPromises.push(
+      (async () => {
+        try {
+          const createdCategory = await loadCategory(categoryData, guild);
+          await Promise.all(
+            categoryData.children
+              .filter(channelData => channelData.name)
+              .map(channelData => loadChannel(channelData, guild, createdCategory, options)),
+          );
+        } catch {
+          // Continue restoring other categories
+        }
+      })(),
+    );
+  });
+
+  backupData.channels.others.forEach(channelData => {
+    if (!channelData.name) return;
+    loadChannelPromises.push(loadChannel(channelData, guild, null, options));
+  });
+
+  await Promise.all(loadChannelPromises);
+}
+
+/**
+ * Restore the afk configuration
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadAFK(guild, backupData) {
+  if (!backupData.afk) return;
+
+  await Promise.all([
+    guild.setAFKChannel(
+      guild.channels.cache.find(ch => ch.name === backupData.afk.name && ch.type === 'GUILD_VOICE'),
+    ),
+    guild.setAFKTimeout(backupData.afk.timeout),
+  ]);
+}
+
+/**
+ * Restore guild emojis
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadEmojis(guild, backupData) {
+  await Promise.all(
+    backupData.emojis.map(emoji => {
+      if (emoji.url) return guild.emojis.create(emoji.url, emoji.name);
+      if (emoji.base64) return guild.emojis.create(Buffer.from(emoji.base64, 'base64'), emoji.name);
+      return Promise.resolve();
+    }),
+  );
+}
+
+/**
+ * Restore guild bans
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadBans(guild, backupData) {
+  await Promise.all(
+    backupData.bans.map(ban =>
+      guild.members.ban(ban.id, {
+        reason: ban.reason,
+      }),
+    ),
+  );
+}
+
+/**
+ * Restore embed channel configuration
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadEmbedChannel(guild, backupData) {
+  if (!backupData.widget.channel) return;
+
+  await guild.setWidgetSettings({
+    enabled: backupData.widget.enabled,
+    channel: guild.channels.cache.find(ch => ch.name === backupData.widget.channel),
+  });
+}
+
+/**
+ * Restore community settings
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadCommunity(guild, backupData) {
+  if (!backupData.community) return;
+
+  const rulesChannelData =
+    backupData.channels.categories.find(c => c.children.find(ch => ch.rulesChannel))?.children.find(
+      ch => ch.rulesChannel,
+    ) || backupData.channels.others.find(c => c.rulesChannel);
+  const publicUpdatesChannelData =
+    backupData.channels.categories
+      .find(c => c.children.find(ch => ch.publicUpdatesChannel))
+      ?.children.find(ch => ch.publicUpdatesChannel) ||
+    backupData.channels.others.find(c => c.publicUpdatesChannel);
+
+  try {
+    const isCommunityEnabled = guild.features.includes('COMMUNITY');
+    const shouldBeCommunityEnabled = backupData.community.enabled;
+
+    if (shouldBeCommunityEnabled && !isCommunityEnabled) {
+      const rulesChannel =
+        rulesChannelData &&
+        guild.channels.cache.find(ch => ch.name === rulesChannelData.name && ch.type === 'GUILD_TEXT');
+      const publicUpdatesChannel =
+        publicUpdatesChannelData &&
+        guild.channels.cache
+          .filter(
+            ch =>
+              ch.name === publicUpdatesChannelData.name &&
+              ch.type === 'GUILD_TEXT' &&
+              ch.id !== rulesChannel?.id,
+          )
+          .first();
+
+      if (rulesChannel && publicUpdatesChannel) {
+        await guild.setCommunity(true, publicUpdatesChannel, rulesChannel, 'Backup');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+      }
+    } else if (shouldBeCommunityEnabled && isCommunityEnabled) {
+      const currentRulesChannel = guild.rulesChannel;
+      const currentPublicUpdatesChannel = guild.publicUpdatesChannel;
+
+      const newRulesChannel =
+        rulesChannelData && guild.channels.cache.find(ch => ch.name === rulesChannelData.name);
+      const newPublicUpdatesChannel =
+        publicUpdatesChannelData &&
+        guild.channels.cache.find(ch => ch.name === publicUpdatesChannelData.name);
+
+      const rulesChannelChanged = newRulesChannel && currentRulesChannel?.id !== newRulesChannel.id;
+      const updatesChannelChanged =
+        newPublicUpdatesChannel && currentPublicUpdatesChannel?.id !== newPublicUpdatesChannel.id;
+
+      if ((rulesChannelChanged || updatesChannelChanged) && newRulesChannel && newPublicUpdatesChannel) {
+        await guild.setRulesChannel(newRulesChannel.id).catch(() => false);
+        await guild.setPublicUpdatesChannel(newPublicUpdatesChannel.id).catch(() => false);
+        currentPublicUpdatesChannel?.delete().catch(() => false);
+        currentRulesChannel?.delete().catch(() => false);
+      }
+    } else if (!shouldBeCommunityEnabled && isCommunityEnabled) {
+      await guild.setCommunity(false, null, null, 'Backup');
+    }
+  } catch {
+    // Ignore community restore errors
+  }
+}
+
+/**
+ * Restore role channel permissions
+ * @param {import('../../structures/Guild').Guild} guild
+ * @param {Object} backupData
+ * @returns {Promise<void>}
+ */
+async function loadRoleChannelPermissions(guild, backupData) {
+  for (const roleData of backupData.roles) {
+    if (!roleData.channelPermissions) continue;
+
+    let role = guild.roles.cache.find(r => r.name === roleData.name);
+    if (!role && roleData.isEveryone) role = guild.roles.cache.get(guild.id);
+    if (!role) continue;
+
+    for (const [channelName, permissions] of Object.entries(roleData.channelPermissions)) {
+      const channel = guild.channels.cache.find(c => c.name === channelName);
+      if (!channel) continue;
+
+      try {
+        await channel.permissionOverwrites.edit(role.id, {
+          allow: Permissions.resolve(permissions.allow),
+          deny: Permissions.resolve(permissions.deny),
+        });
+        await new Promise(resolve => setTimeout(resolve, 200));
+      } catch {
+        // Continue with next permission
+      }
+    }
+  }
+}
+
+module.exports = {
+  loadConfig,
+  loadRoles,
+  loadChannels,
+  loadAFK,
+  loadEmojis,
+  loadBans,
+  loadEmbedChannel,
+  loadCommunity,
+  loadRoleChannelPermissions,
+};