discord-self-lite 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-self-lite",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Lightweight Discord selfbot library",
   "keywords": [
     "discord",

package/src/classes/BitField.js

@@ -0,0 +1,110 @@
+/**
+ * A BitField is a data structure that makes it easy to interact with a bitfield.
+ */
+class BitField {
+  /**
+   * @param {BitFieldResolvable} [bits=BitField.defaultBit] Bit(s) to read from
+   */
+  constructor(bits = BitField.defaultBit) {
+    /**
+     * Bitfield of the packed bits
+     * @type {bigint}
+     */
+    this.bitfield = BitField.resolve(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or any of multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  any(bit) {
+    return (this.bitfield & BitField.resolve(bit)) !== BitField.defaultBit;
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  has(bit) {
+    bit = BitField.resolve(bit);
+    return (this.bitfield & bit) === bit;
+  }
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @returns {string[]}
+   */
+  missing(bits) {
+    const res = [];
+    const bit = BitField.resolve(bits);
+
+    for (const [flag, value] of Object.entries(this.constructor.FLAGS)) {
+      if ((bit & value) !== value) continue;
+      if ((this.bitfield & value) === value) continue;
+      res.push(flag);
+    }
+
+    return res;
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the bits available.
+   * @param {boolean} [has=true] Whether to show bits that are set
+   * @returns {string[]}
+   */
+  toArray(has = true) {
+    const arr = [];
+
+    for (const [flag, value] of Object.entries(this.constructor.FLAGS)) {
+      if (has) {
+        if ((this.bitfield & value) === value) arr.push(flag);
+      } else {
+        if ((this.bitfield & value) !== value) arr.push(flag);
+      }
+    }
+
+    return arr;
+  }
+
+  /**
+   * Data that can be resolved to give a bitfield. This can be:
+   * * A string (see {@link BitField.FLAGS})
+   * * A bit number
+   * * An instance of BitField
+   * * An Array of BitFieldResolvable
+   * @typedef {string|bigint|BitField|BitFieldResolvable[]} BitFieldResolvable
+   */
+
+  /**
+   * Resolves bitfields to their numeric form.
+   * @param {BitFieldResolvable} [bit=BitField.defaultBit] bit(s) to resolve
+   * @returns {bigint}
+   */
+  static resolve(bit = BitField.defaultBit) {
+    if (typeof bit === "bigint" && bit >= BitField.defaultBit) return bit;
+    if (bit instanceof BitField) return bit.bitfield;
+    if (Array.isArray(bit))
+      return bit
+        .map((p) => this.resolve(p))
+        .reduce((prev, p) => prev | p, BitField.defaultBit);
+    if (typeof bit === "string") return this.FLAGS[bit];
+    throw new TypeError("BitField.resolve: Invalid bitfield");
+  }
+}
+
+/**
+ * Numeric bitfield flags.
+ * @type {Object<string, bigint>}
+ */
+BitField.FLAGS = {};
+
+/**
+ * The default bit to use if none are provided.
+ * @type {bigint}
+ */
+BitField.defaultBit = 0n;
+
+module.exports = BitField;

package/src/classes/Channel.js

@@ -1,6 +1,8 @@
 /**
  * Represents a Discord channel
  */
+const Permissions = require("./Permissions");
+
 class Channel {
   /**
    * Create a new Channel instance
@@ -161,6 +163,54 @@ class Channel {
     const guildId = this.data.guild_id;
     return `https://discord.com/channels/${guildId}/${this.id}`;
   }
+
+  /**
+   * Check permissions for a member in this channel
+   * @param {GuildMember} member - The guild member to check permissions for
+   * @returns {Permissions} Permissions bitfield for this member in this channel
+   */
+  permissionsFor(member) {
+    if (!member) return new Permissions(BigInt(0));
+
+    // Start with the member's base guild permissions
+    let permissions = member.permissions.bitfield;
+
+    // If member has administrator, they have all permissions
+    if (member.permissions.has(Permissions.FLAGS.ADMINISTRATOR)) {
+      return new Permissions(Permissions.ALL);
+    }
+
+    // Apply channel permission overwrites
+    if (this.data.permission_overwrites) {
+      const overwrites = this.data.permission_overwrites;
+
+      // Role overwrites (deny takes precedence over allow)
+      const memberRoles = member.roles || [];
+      for (const overwrite of overwrites) {
+        if (overwrite.type === 0) {
+          // Role overwrite
+          if (
+            memberRoles.includes(overwrite.id) ||
+            overwrite.id === this.data.guild_id
+          ) {
+            permissions &= ~BigInt(overwrite.deny || 0);
+            permissions |= BigInt(overwrite.allow || 0);
+          }
+        }
+      }
+
+      // Member-specific overwrites (takes precedence over role overwrites)
+      const memberOverwrite = overwrites.find(
+        (ow) => ow.type === 1 && ow.id === member.id,
+      );
+      if (memberOverwrite) {
+        permissions &= ~BigInt(memberOverwrite.deny || 0);
+        permissions |= BigInt(memberOverwrite.allow || 0);
+      }
+    }
+
+    return new Permissions(permissions);
+  }
 }
 
 module.exports = Channel;

package/src/classes/Guild.js

@@ -36,6 +36,9 @@ class Guild {
 
     // Cache for guild members
     this._members = new Map();
+
+    // Initialize roles from guild data
+    this.roles = this.data.roles || [];
   }
 
   /**

package/src/classes/GuildMember.js

@@ -1,6 +1,8 @@
 /**
  * Represents a Discord guild member
  */
+const Permissions = require("./Permissions");
+
 class GuildMember {
   /**
    * Create a new GuildMember instance
@@ -50,16 +52,45 @@ class GuildMember {
 
   /**
    * Get the member's permissions in this guild
-   * @returns {Array<string>} Array of permission strings
+   * @returns {Permissions} Permissions bitfield
    */
   get permissions() {
-    // This is a simplified implementation
-    // In a full implementation, you'd calculate permissions based on roles
+    if (this._permissions) return this._permissions;
+
+    // Calculate permissions based on roles
+    let permissions = BigInt(0);
+
+    // If member is the guild owner, they have all permissions
+    if (this.id === this.guild.ownerId) {
+      permissions = Permissions.ALL;
+    } else {
+      // Start with @everyone role permissions
+      const everyoneRole = this.guild.roles?.find(
+        (role) => role.id === this.guild.id,
+      );
+      if (everyoneRole) {
+        permissions |= BigInt(everyoneRole.permissions || 0);
+      }
+
+      // Add permissions from member's roles
+      for (const roleId of this.roles || []) {
+        const role = this.guild.roles?.find((r) => r.id === roleId);
+        if (role) {
+          permissions |= BigInt(role.permissions || 0);
+        }
+      }
+    }
+
+    this._permissions = new Permissions(permissions);
     return this._permissions;
   }
 
   set permissions(value) {
-    this._permissions = value ?? null;
+    if (value instanceof Permissions) {
+      this._permissions = value;
+    } else {
+      this._permissions = new Permissions(value);
+    }
   }
 
   /**

package/src/classes/Permissions.js

@@ -0,0 +1,212 @@
+"use strict";
+
+const BitField = require("./BitField");
+
+/**
+ * Data structure that makes it easy to interact with a permission bitfield. All {@link GuildMember}s have a set of
+ * permissions in their guild, and each channel in the guild may also have {@link PermissionOverwrites} for the member
+ * that override their default permissions.
+ * @extends {BitField}
+ */
+class Permissions extends BitField {
+  /**
+   * Bitfield of the packed bits
+   * @type {bigint}
+   * @name Permissions#bitfield
+   */
+
+  /**
+   * Data that can be resolved to give a permission number. This can be:
+   * * A string (see {@link Permissions.FLAGS})
+   * * A permission number
+   * * An instance of Permissions
+   * * An Array of PermissionResolvable
+   * @typedef {string|bigint|Permissions|PermissionResolvable[]} PermissionResolvable
+   */
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {string[]}
+   */
+  missing(bits, checkAdmin = true) {
+    return checkAdmin && this.has(this.constructor.FLAGS.ADMINISTRATOR)
+      ? []
+      : super.missing(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or any of multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  any(permission, checkAdmin = true) {
+    return (
+      (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) ||
+      super.any(permission)
+    );
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  has(permission, checkAdmin = true) {
+    return (
+      (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) ||
+      super.has(permission)
+    );
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the permissions available.
+   * @returns {string[]}
+   */
+  toArray() {
+    return super.toArray(false);
+  }
+}
+
+/**
+ * Numeric permission flags. All available properties:
+ * * `CREATE_INSTANT_INVITE` (create invitations to the guild)
+ * * `KICK_MEMBERS`
+ * * `BAN_MEMBERS`
+ * * `ADMINISTRATOR` (implicitly has *all* permissions, and bypasses all channel overwrites)
+ * * `MANAGE_CHANNELS` (edit and reorder channels)
+ * * `MANAGE_GUILD` (edit the guild information, region, etc.)
+ * * `ADD_REACTIONS` (add new reactions to messages)
+ * * `VIEW_AUDIT_LOG`
+ * * `PRIORITY_SPEAKER`
+ * * `STREAM`
+ * * `VIEW_CHANNEL`
+ * * `SEND_MESSAGES`
+ * * `SEND_TTS_MESSAGES`
+ * * `MANAGE_MESSAGES` (delete messages and reactions)
+ * * `EMBED_LINKS` (links posted will have a preview embedded)
+ * * `ATTACH_FILES`
+ * * `READ_MESSAGE_HISTORY` (view messages that were posted prior to opening Discord)
+ * * `MENTION_EVERYONE`
+ * * `USE_EXTERNAL_EMOJIS` (use emojis from different guilds)
+ * * `VIEW_GUILD_INSIGHTS`
+ * * `CONNECT` (connect to a voice channel)
+ * * `SPEAK` (speak in a voice channel)
+ * * `MUTE_MEMBERS` (mute members across all voice channels)
+ * * `DEAFEN_MEMBERS` (deafen members across all voice channels)
+ * * `MOVE_MEMBERS` (move members between voice channels)
+ * * `USE_VAD` (use voice activity detection)
+ * * `CHANGE_NICKNAME`
+ * * `MANAGE_NICKNAMES` (change other members' nicknames)
+ * * `MANAGE_ROLES`
+ * * `MANAGE_WEBHOOKS`
+ * * `MANAGE_EMOJIS_AND_STICKERS`
+ * * `USE_APPLICATION_COMMANDS`
+ * * `REQUEST_TO_SPEAK`
+ * * `MANAGE_EVENTS`
+ * * `MANAGE_THREADS`
+ * * `USE_PUBLIC_THREADS` (deprecated)
+ * * `CREATE_PUBLIC_THREADS`
+ * * `USE_PRIVATE_THREADS` (deprecated)
+ * * `CREATE_PRIVATE_THREADS`
+ * * `USE_EXTERNAL_STICKERS` (use stickers from different guilds)
+ * * `SEND_MESSAGES_IN_THREADS`
+ * * `START_EMBEDDED_ACTIVITIES`
+ * * `MODERATE_MEMBERS`
+ * * `VIEW_CREATOR_MONETIZATION_ANALYTICS`
+ * * `USE_SOUNDBOARD`
+ * * `CREATE_GUILD_EXPRESSIONS`
+ * * `CREATE_EVENTS`
+ * * `USE_EXTERNAL_SOUNDS`
+ * * `SEND_VOICE_MESSAGES`
+ * * `USE_CLYDE_AI`
+ * * `SET_VOICE_CHANNEL_STATUS`
+ * * `SEND_POLLS`
+ * * `USE_EXTERNAL_APPS`
+ * @type {Object<string, bigint>}
+ * @see {@link https://discord.com/developers/docs/topics/permissions#permissions-bitwise-permission-flags}
+ */
+Permissions.FLAGS = {
+  CREATE_INSTANT_INVITE: 1n << 0n,
+  KICK_MEMBERS: 1n << 1n,
+  BAN_MEMBERS: 1n << 2n,
+  ADMINISTRATOR: 1n << 3n,
+  MANAGE_CHANNELS: 1n << 4n,
+  MANAGE_GUILD: 1n << 5n,
+  ADD_REACTIONS: 1n << 6n,
+  VIEW_AUDIT_LOG: 1n << 7n,
+  PRIORITY_SPEAKER: 1n << 8n,
+  STREAM: 1n << 9n,
+  VIEW_CHANNEL: 1n << 10n,
+  SEND_MESSAGES: 1n << 11n,
+  SEND_TTS_MESSAGES: 1n << 12n,
+  MANAGE_MESSAGES: 1n << 13n,
+  EMBED_LINKS: 1n << 14n,
+  ATTACH_FILES: 1n << 15n,
+  READ_MESSAGE_HISTORY: 1n << 16n,
+  MENTION_EVERYONE: 1n << 17n,
+  USE_EXTERNAL_EMOJIS: 1n << 18n,
+  VIEW_GUILD_INSIGHTS: 1n << 19n,
+  CONNECT: 1n << 20n,
+  SPEAK: 1n << 21n,
+  MUTE_MEMBERS: 1n << 22n,
+  DEAFEN_MEMBERS: 1n << 23n,
+  MOVE_MEMBERS: 1n << 24n,
+  USE_VAD: 1n << 25n,
+  CHANGE_NICKNAME: 1n << 26n,
+  MANAGE_NICKNAMES: 1n << 27n,
+  MANAGE_ROLES: 1n << 28n,
+  MANAGE_WEBHOOKS: 1n << 29n,
+  MANAGE_EMOJIS_AND_STICKERS: 1n << 30n,
+  USE_APPLICATION_COMMANDS: 1n << 31n,
+  REQUEST_TO_SPEAK: 1n << 32n,
+  MANAGE_EVENTS: 1n << 33n,
+  MANAGE_THREADS: 1n << 34n,
+  CREATE_PUBLIC_THREADS: 1n << 35n,
+  CREATE_PRIVATE_THREADS: 1n << 36n,
+  USE_EXTERNAL_STICKERS: 1n << 37n,
+  SEND_MESSAGES_IN_THREADS: 1n << 38n,
+  START_EMBEDDED_ACTIVITIES: 1n << 39n,
+  MODERATE_MEMBERS: 1n << 40n,
+  VIEW_CREATOR_MONETIZATION_ANALYTICS: 1n << 41n,
+  USE_SOUNDBOARD: 1n << 42n,
+  CREATE_GUILD_EXPRESSIONS: 1n << 43n,
+  CREATE_EVENTS: 1n << 44n,
+  USE_EXTERNAL_SOUNDS: 1n << 45n,
+  SEND_VOICE_MESSAGES: 1n << 46n,
+  USE_CLYDE_AI: 1n << 47n,
+  SET_VOICE_CHANNEL_STATUS: 1n << 48n,
+  SEND_POLLS: 1n << 49n,
+  USE_EXTERNAL_APPS: 1n << 50n,
+};
+
+/**
+ * Bitfield representing every permission combined
+ * @type {bigint}
+ */
+Permissions.ALL = Object.values(Permissions.FLAGS).reduce(
+  (all, p) => all | p,
+  0n,
+);
+
+/**
+ * Bitfield representing the default permissions for users
+ * @type {bigint}
+ */
+Permissions.DEFAULT = BigInt(104324673);
+
+/**
+ * Bitfield representing the permissions required for moderators of stage channels
+ * @type {bigint}
+ */
+Permissions.STAGE_MODERATOR =
+  Permissions.FLAGS.MANAGE_CHANNELS |
+  Permissions.FLAGS.MUTE_MEMBERS |
+  Permissions.FLAGS.MOVE_MEMBERS;
+
+Permissions.defaultBit = BigInt(0);
+
+module.exports = Permissions;

package/src/index.js

@@ -19,6 +19,8 @@
 
 const Client = require("./classes/Client");
 const WebhookClient = require("./connection/webhook/WebhookClient");
+const Permissions = require("./classes/Permissions");
+const BitField = require("./classes/BitField");
 
 /**
  * Main package exports
@@ -38,4 +40,18 @@ module.exports = {
    * @see {@link WebhookClient}
    */
   WebhookClient,
+
+  /**
+   * Discord permission flags and utilities
+   * @type {Permissions}
+   * @see {@link Permissions}
+   */
+  Permissions,
+
+  /**
+   * Base class for handling bitfields
+   * @type {BitField}
+   * @see {@link BitField}
+   */
+  BitField,
 };