discord-self-lite 0.1.6 → 0.1.8

package/package.json

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

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/connection/rest/RestManager.js

@@ -23,6 +23,9 @@ class RestManager {
     this.globalRateLimit = null; // { reset }
     this.requestQueue = [];
     this.processingQueue = false;
+
+    // Circuit breaker state for heavily rate-limited routes
+    this.circuitBreakers = new Map(); // routeKey -> { failures, lastFailure, openUntil }
   }
 
   /**
@@ -33,7 +36,56 @@ class RestManager {
    * @throws {Error} If the request fails
    */
   async request(endpoint, options = {}) {
+    // Check rate limits before queuing the request with more aggressive logic
+    const method = options.method || "GET";
+    const routeKey = this.getRouteKey(endpoint, method);
+
+    // Check circuit breaker - reject immediately if route is temporarily disabled
+    const circuitBreaker = this.circuitBreakers.get(routeKey);
+    if (circuitBreaker && circuitBreaker.openUntil > Date.now()) {
+      const remainingTime = circuitBreaker.openUntil - Date.now();
+      throw new Error(
+        `Circuit breaker open for ${routeKey}. Retry in ${remainingTime}ms`,
+      );
+    }
+
+    if (this.isRateLimited(endpoint, method)) {
+      const rateLimit = this.rateLimits.get(routeKey);
+      const globalLimited =
+        this.globalRateLimit && Date.now() < this.globalRateLimit.reset;
+
+      // Calculate delay with minimum 2s buffer and more conservative timing
+      const baseDelay = globalLimited
+        ? this.globalRateLimit.reset - Date.now()
+        : rateLimit
+          ? rateLimit.reset - Date.now()
+          : 1000;
+
+      // Add buffer time and ensure minimum delay
+      const delay = Math.max(baseDelay + 2000, 3000); // Minimum 3s delay
+
+      console.log(
+        `🚫 Pre-emptive rate limit wait: ${delay}ms for ${routeKey} (${endpoint})`,
+      );
+      await this.sleep(delay);
+
+      // Double-check after waiting - if still limited, reject immediately
+      if (this.isRateLimited(endpoint, method)) {
+        throw new Error(`Endpoint still rate limited after wait: ${routeKey}`);
+      }
+    }
+
     return new Promise((resolve, reject) => {
+      // Prevent queue from growing too large during rate limit storms
+      if (this.requestQueue.length >= 50) {
+        reject(
+          new Error(
+            `Request queue full (${this.requestQueue.length} requests). Rate limiting too aggressive.`,
+          ),
+        );
+        return;
+      }
+
       this.requestQueue.push({
         endpoint,
         options,
@@ -55,10 +107,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`);
@@ -84,13 +146,21 @@ class RestManager {
             `⏳ 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);
         resolve(result);
 
-        // Small delay between requests to be nice to Discord
-        await this.sleep(100);
+        // Increased delay between requests to be more conservative with rate limits
+        await this.sleep(500);
       } catch (error) {
         reject(error);
       }
@@ -134,17 +204,52 @@ class RestManager {
             response.headers.get("x-ratelimit-global") === "true";
           const routeKey = this.getRouteKey(endpoint, options.method || "GET");
 
+          // Exponential backoff: increase delay based on attempt number
+          const backoffDelay = retryAfter * Math.pow(1.5, attempt);
+
           console.log(
             `🚫 Rate limited! ${
               isGlobal ? "Global" : `Route (${routeKey})`
-            } limit for ${endpoint}, retry after ${retryAfter}ms`,
+            } limit for ${endpoint}, retry after ${backoffDelay}ms (attempt ${attempt + 1})`,
           );
 
+          // Circuit breaker: track consecutive failures
+          if (!isGlobal) {
+            const breaker = this.circuitBreakers.get(routeKey) || {
+              failures: 0,
+              lastFailure: 0,
+              openUntil: 0,
+            };
+            breaker.failures++;
+            breaker.lastFailure = Date.now();
+
+            // Open circuit breaker after 3 consecutive failures within 30 seconds
+            if (
+              breaker.failures >= 3 &&
+              Date.now() - breaker.lastFailure < 30000
+            ) {
+              breaker.openUntil = Date.now() + 60000; // Open for 60 seconds
+              console.log(
+                `🔌 Circuit breaker OPENED for ${routeKey} - too many rate limits`,
+              );
+            }
+
+            this.circuitBreakers.set(routeKey, breaker);
+          }
+
           if (isGlobal) {
-            this.globalRateLimit = { reset: Date.now() + retryAfter };
+            this.globalRateLimit = { reset: Date.now() + backoffDelay };
+          } else {
+            // Update route-specific rate limit for 429 responses
+            this.rateLimits.set(routeKey, {
+              remaining: 0,
+              reset: Date.now() + backoffDelay,
+              limit: this.rateLimits.get(routeKey)?.limit || 5, // Default limit if unknown
+              updatedAt: Date.now(),
+            });
           }
 
-          await this.sleep(retryAfter);
+          await this.sleep(backoffDelay);
           attempt++;
           continue;
         }
@@ -158,9 +263,16 @@ class RestManager {
 
         // Handle 204 No Content (successful but no body)
         if (response.status === 204) {
+          // Reset circuit breaker on successful response
+          const routeKey = this.getRouteKey(endpoint, options.method || "GET");
+          this.circuitBreakers.delete(routeKey);
           return null;
         }
 
+        // Reset circuit breaker on successful response
+        const routeKey = this.getRouteKey(endpoint, options.method || "GET");
+        this.circuitBreakers.delete(routeKey);
+
         return await response.json();
       } catch (error) {
         if (attempt === maxRetries - 1) {
@@ -232,16 +344,80 @@ class RestManager {
         this.rateLimits.delete(key);
       }
     }
+
+    // Clean up expired circuit breakers
+    for (const [key, breaker] of this.circuitBreakers.entries()) {
+      if (now > breaker.openUntil) {
+        this.circuitBreakers.delete(key);
+      }
+    }
   }
 
   /**
-   * Sleep for a given duration
+   * Sleep for a specified number of milliseconds
    * @private
+   * @param {number} ms - Milliseconds to sleep
+   * @returns {Promise<void>}
    */
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  /**
+   * 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
+   */
+  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,
+    };
+  }
+
   /**
    * Send a message to a channel
    * @param {string} channelId - The channel ID

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