discord-self-lite 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-self-lite",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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/Client.js

@@ -191,6 +191,32 @@ class Client extends EventEmitter {
     return this.token;
   }
 
+  /**
+   * Get rate limit status for debugging
+   * @param {string} endpoint - The API endpoint
+   * @param {string} method - The HTTP method (default: 'GET')
+   * @returns {object} Rate limit information
+   */
+  getRateLimitStatus(endpoint, method = "GET") {
+    if (!this.rest) {
+      throw new Error("Client is not logged in");
+    }
+    return this.rest.getRateLimitStatus(endpoint, method);
+  }
+
+  /**
+   * Check if a route is currently rate limited
+   * @param {string} endpoint - The API endpoint
+   * @param {string} method - The HTTP method (default: 'GET')
+   * @returns {boolean} True if rate limited
+   */
+  isRateLimited(endpoint, method = "GET") {
+    if (!this.rest) {
+      return false;
+    }
+    return this.rest.isRateLimited(endpoint, method);
+  }
+
   /**
    * Destroy the client and clean up resources
    * @returns {void}

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

@@ -55,10 +55,20 @@ class RestManager {
       return;
     }
 
+    // Check if we're globally rate limited before starting
+    if (this.globalRateLimit && Date.now() < this.globalRateLimit.reset) {
+      const delay = this.globalRateLimit.reset - Date.now();
+      console.log(
+        `⏳ Global rate limit active, waiting ${delay}ms before processing queue`,
+      );
+      setTimeout(() => this.processQueue(), delay);
+      return;
+    }
+
     this.processingQueue = true;
 
     while (this.requestQueue.length > 0) {
-      // Check global rate limit
+      // Double-check global rate limit for each request
       if (this.globalRateLimit && Date.now() < this.globalRateLimit.reset) {
         const delay = this.globalRateLimit.reset - Date.now();
         console.log(`⏳ Global rate limit active, waiting ${delay}ms`);
@@ -81,9 +91,17 @@ 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);
+
+          // After waiting, check if we still have remaining requests
+          const updatedRateLimit = this.rateLimits.get(routeKey);
+          if (updatedRateLimit && updatedRateLimit.remaining <= 0) {
+            // Still rate limited, put request back at front of queue
+            this.requestQueue.unshift(request);
+            continue;
+          }
         }
 
         const result = await this.makeRequest(endpoint, options);
@@ -129,18 +147,27 @@ 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) {
             this.globalRateLimit = { reset: Date.now() + retryAfter };
+          } else {
+            // Update route-specific rate limit for 429 responses
+            this.rateLimits.set(routeKey, {
+              remaining: 0,
+              reset: Date.now() + retryAfter,
+              limit: this.rateLimits.get(routeKey)?.limit || 5, // Default limit if unknown
+              updatedAt: Date.now(),
+            });
           }
 
           await this.sleep(retryAfter);
@@ -234,11 +261,58 @@ class RestManager {
   }
 
   /**
-   * Sleep for a given duration
-   * @private
+   * Check if a route is currently rate limited
+   * @param {string} endpoint - The API endpoint
+   * @param {string} method - The HTTP method
+   * @returns {boolean} True if rate limited
+   */
+  isRateLimited(endpoint, method = "GET") {
+    // Check global rate limit
+    if (this.globalRateLimit && Date.now() < this.globalRateLimit.reset) {
+      return true;
+    }
+
+    // Check route-specific rate limit
+    const routeKey = this.getRouteKey(endpoint, method);
+    const rateLimit = this.rateLimits.get(routeKey);
+
+    return (
+      rateLimit && rateLimit.remaining <= 0 && Date.now() < rateLimit.reset
+    );
+  }
+
+  /**
+   * Get rate limit status for debugging
+   * @param {string} endpoint - The API endpoint
+   * @param {string} method - The HTTP method
+   * @returns {object} Rate limit information
    */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  getRateLimitStatus(endpoint, method = "GET") {
+    const routeKey = this.getRouteKey(endpoint, method);
+    const rateLimit = this.rateLimits.get(routeKey);
+
+    return {
+      routeKey,
+      endpoint,
+      method,
+      isGloballyLimited:
+        this.globalRateLimit && Date.now() < this.globalRateLimit.reset,
+      globalReset: this.globalRateLimit
+        ? new Date(this.globalRateLimit.reset)
+        : null,
+      isRouteLimited:
+        rateLimit && rateLimit.remaining <= 0 && Date.now() < rateLimit.reset,
+      routeLimit: rateLimit
+        ? {
+            remaining: rateLimit.remaining,
+            limit: rateLimit.limit,
+            reset: new Date(rateLimit.reset),
+            resetIn: Math.max(0, rateLimit.reset - Date.now()),
+          }
+        : null,
+      queueLength: this.requestQueue.length,
+      isProcessing: this.processingQueue,
+    };
   }
 
   /**

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

@@ -1,7 +1,7 @@
 /**
  * discord-self-lite - A lightweight Discord selfbot library
  * @module discord-self-lite
- * @version 0.1.0
+ * @version 0.1.7
  * @description A modern, lightweight Discord selfbot library with webhook support, built for Node.js 22+ with zero external dependencies (except ws for WebSocket connections).
  *
  * @example