discord-self-lite 0.1.4 → 0.1.6

package/package.json

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

package/src/classes/BitField.js

@@ -0,0 +1,116 @@
+/**
+ * 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") {
+      // Check if it's a numeric string (permission bitfield from API)
+      if (/^\d+$/.test(bit)) return BigInt(bit);
+      // Otherwise treat as flag name
+      return this.FLAGS[bit];
+    }
+    if (typeof bit === "number") return BigInt(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,20 @@
 /**
  * Represents a Discord channel
  */
+const Permissions = require("./Permissions");
+
+/**
+ * Safe BigInt conversion
+ * @param {*} value - Value to convert to BigInt
+ * @returns {bigint} BigInt representation
+ */
+function toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "string") return BigInt(value);
+  if (typeof value === "number") return BigInt(value);
+  return 0n;
+}
+
 class Channel {
   /**
    * Create a new Channel instance
@@ -161,6 +175,104 @@ 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?.permissions) return new Permissions(toBigInt(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 &= ~toBigInt(overwrite.deny || 0);
+            permissions |= toBigInt(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 &= ~toBigInt(memberOverwrite.deny || 0);
+        permissions |= toBigInt(memberOverwrite.allow || 0);
+      }
+    }
+
+    return new Permissions(permissions);
+  }
+
+  /**
+   * Wait for a message in this channel
+   * @param {object} [options={}] - Options for awaiting messages
+   * @param {Function} [options.filter] - Filter function for messages (must return true/false)
+   * @param {number} [options.time=30000] - Timeout in milliseconds
+   * @param {boolean} [options.errors=true] - Whether to reject on timeout
+   * @returns {Promise<Message>} The matching message
+   * @throws {Error} If timeout is reached and errors is true
+   * @example
+   * // Wait for any message
+   * const msg = await channel.awaitMessage();
+   *
+   * // Wait for a message from specific user
+   * const msg = await channel.awaitMessage({
+   *   filter: (m) => m.author.id === '123456789',
+   *   time: 60000
+   * });
+   *
+   * // Wait for message with specific content patterns
+   * const msg = await channel.awaitMessage({
+   *   filter: (m) => m.author.id === userId &&
+   *                  (m.content.includes('yes') || m.content.includes('confirm')),
+   *   time: 30000
+   * });
+   */
+  async awaitMessage(options = {}) {
+    const { filter = () => true, time = 30000, errors = true } = options;
+
+    return new Promise((resolve, reject) => {
+      const listener = (message) => {
+        if (message.channelId === this.id && filter(message)) {
+          this.client.removeListener("messageCreate", listener);
+          clearTimeout(timeout);
+          resolve(message);
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        this.client.removeListener("messageCreate", listener);
+        if (errors) {
+          reject(new Error("Message await timed out"));
+        } else {
+          resolve(null);
+        }
+      }, time);
+
+      this.client.on("messageCreate", listener);
+    });
+  }
 }
 
 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,20 @@
 /**
  * Represents a Discord guild member
  */
+const Permissions = require("./Permissions");
+
+/**
+ * Safe BigInt conversion
+ * @param {*} value - Value to convert to BigInt
+ * @returns {bigint} BigInt representation
+ */
+function toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "string") return BigInt(value);
+  if (typeof value === "number") return BigInt(value);
+  return 0n;
+}
+
 class GuildMember {
   /**
    * Create a new GuildMember instance
@@ -50,16 +64,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 = 0n;
+
+    // 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 && everyoneRole.permissions != null) {
+        permissions |= toBigInt(everyoneRole.permissions);
+      }
+
+      // Add permissions from member's roles
+      for (const roleId of this.roles || []) {
+        const role = this.guild.roles?.find((r) => r.id === roleId);
+        if (role && role.permissions != null) {
+          permissions |= toBigInt(role.permissions);
+        }
+      }
+    }
+
+    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/connection/rest/RestManager.js

@@ -81,7 +81,7 @@ class RestManager {
         ) {
           const delay = rateLimit.reset - Date.now();
           console.log(
-            `⏳ Route rate limit for ${routeKey}, waiting ${delay}ms`,
+            `⏳ Route rate limit for ${routeKey} (${endpoint}), waiting ${delay}ms`,
           );
           await this.sleep(delay);
         }
@@ -129,14 +129,15 @@ class RestManager {
         // Handle rate limiting
         if (response.status === 429) {
           const retryAfter =
-            parseInt(response.headers.get("retry-after")) * 1000;
+            parseInt(response.headers.get("retry-after")) * 1000 + 1000;
           const isGlobal =
             response.headers.get("x-ratelimit-global") === "true";
+          const routeKey = this.getRouteKey(endpoint, options.method || "GET");
 
           console.log(
             `🚫 Rate limited! ${
-              isGlobal ? "Global" : "Route"
-            } limit, retry after ${retryAfter}ms`,
+              isGlobal ? "Global" : `Route (${routeKey})`
+            } limit for ${endpoint}, retry after ${retryAfter}ms`,
           );
 
           if (isGlobal) {

package/src/connection/webhook/WebhookClient.js

@@ -1,5 +1,24 @@
 const DiscordAPIError = require("../../classes/DiscordAPIError");
 
+/**
+ * Convert a color value to Discord's expected integer format
+ * @param {*} color - Color value (hex string, number, etc.)
+ * @returns {number|null} Integer color value or null
+ */
+function resolveColor(color) {
+  if (color === null || color === undefined) return null;
+  if (typeof color === "number") return color;
+  if (typeof color === "string") {
+    // Handle hex colors
+    if (color.startsWith("#")) {
+      return parseInt(color.slice(1), 16);
+    }
+    // Handle other string formats if needed
+    return parseInt(color, 16);
+  }
+  return null;
+}
+
 class WebhookClient {
   /**
    * Create a new WebhookClient
@@ -186,7 +205,10 @@ class WebhookClient {
       payload.avatar_url = options.avatarURL;
     }
     if (options.embeds) {
-      payload.embeds = options.embeds;
+      payload.embeds = options.embeds.map((embed) => ({
+        ...embed,
+        color: resolveColor(embed.color),
+      }));
     }
     if (options.tts !== undefined) {
       payload.tts = options.tts;
@@ -212,11 +234,11 @@ class WebhookClient {
       description: data.description || null,
       url: data.url || null,
       timestamp: data.timestamp || null,
-      color: data.color || null,
+      color: resolveColor(data.color),
       footer: data.footer
         ? {
             text: data.footer.text,
-            icon_url: data.footer.iconURL,
+            icon_url: data.footer.iconURL || data.footer.icon_url,
           }
         : null,
       image: data.image ? { url: data.image } : null,
@@ -225,7 +247,7 @@ class WebhookClient {
         ? {
             name: data.author.name,
             url: data.author.url,
-            icon_url: data.author.iconURL,
+            icon_url: data.author.iconURL || data.author.icon_url,
           }
         : null,
       fields: data.fields || [],

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,
 };