discord-self-lite 0.1.5 → 0.1.6

package/package.json

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

package/src/classes/BitField.js

@@ -90,7 +90,13 @@ class BitField {
       return bit
         .map((p) => this.resolve(p))
         .reduce((prev, p) => prev | p, BitField.defaultBit);
-    if (typeof bit === "string") return this.FLAGS[bit];
+    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");
   }
 }

package/src/classes/Channel.js

@@ -3,6 +3,18 @@
  */
 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
@@ -170,7 +182,7 @@ class Channel {
    * @returns {Permissions} Permissions bitfield for this member in this channel
    */
   permissionsFor(member) {
-    if (!member) return new Permissions(BigInt(0));
+    if (!member?.permissions) return new Permissions(toBigInt(0));
 
     // Start with the member's base guild permissions
     let permissions = member.permissions.bitfield;
@@ -193,8 +205,8 @@ class Channel {
             memberRoles.includes(overwrite.id) ||
             overwrite.id === this.data.guild_id
           ) {
-            permissions &= ~BigInt(overwrite.deny || 0);
-            permissions |= BigInt(overwrite.allow || 0);
+            permissions &= ~toBigInt(overwrite.deny || 0);
+            permissions |= toBigInt(overwrite.allow || 0);
           }
         }
       }
@@ -204,13 +216,63 @@ class Channel {
         (ow) => ow.type === 1 && ow.id === member.id,
       );
       if (memberOverwrite) {
-        permissions &= ~BigInt(memberOverwrite.deny || 0);
-        permissions |= BigInt(memberOverwrite.allow || 0);
+        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/GuildMember.js

@@ -3,6 +3,18 @@
  */
 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
@@ -58,7 +70,7 @@ class GuildMember {
     if (this._permissions) return this._permissions;
 
     // Calculate permissions based on roles
-    let permissions = BigInt(0);
+    let permissions = 0n;
 
     // If member is the guild owner, they have all permissions
     if (this.id === this.guild.ownerId) {
@@ -68,15 +80,15 @@ class GuildMember {
       const everyoneRole = this.guild.roles?.find(
         (role) => role.id === this.guild.id,
       );
-      if (everyoneRole) {
-        permissions |= BigInt(everyoneRole.permissions || 0);
+      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) {
-          permissions |= BigInt(role.permissions || 0);
+        if (role && role.permissions != null) {
+          permissions |= toBigInt(role.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 || [],