fca-neokex-fix 1.0.1

package/src/utils/rateLimiter.js

@@ -0,0 +1,380 @@
+"use strict";
+
+/**
+ * Adaptive Rate Limiting Manager
+ * Prevents overwhelming Facebook servers and manages request cooldowns
+ * Enhanced with behavioral modeling and context-aware throttling
+ */
+
+class RateLimiter {
+    constructor() {
+        this.threadCooldowns = new Map();
+        this.endpointCooldowns = new Map();
+        this.requestCounts = new Map();
+        this.errorCache = new Map();
+        this.requestHistory = new Map();
+        this.behavioralMetrics = new Map();
+        this.checkpointMode = false;
+        this.ERROR_CACHE_TTL = 300000; // 5 minutes
+        this.COOLDOWN_DURATION = 60000; // 60 seconds
+        this.MAX_REQUESTS_PER_MINUTE = 60;
+        this.MAX_CONCURRENT_REQUESTS = 8;
+        this.BURST_THRESHOLD = 5;
+        this.BURST_WINDOW_MS = 10000;
+        this.activeRequests = 0;
+        this.QUIET_HOURS = { start: 2, end: 6 };
+    }
+
+    /**
+     * Check if a thread is on cooldown
+     * @param {string} threadID - Thread identifier
+     * @returns {boolean}
+     */
+    isThreadOnCooldown(threadID) {
+        const cooldownEnd = this.threadCooldowns.get(threadID);
+        if (!cooldownEnd) return false;
+
+        const now = Date.now();
+        if (now >= cooldownEnd) {
+            this.threadCooldowns.delete(threadID);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Put a thread on cooldown
+     * @param {string} threadID - Thread identifier
+     * @param {number} duration - Cooldown duration in milliseconds
+     */
+    setThreadCooldown(threadID, duration = null) {
+        const cooldownDuration = duration || this.COOLDOWN_DURATION;
+        this.threadCooldowns.set(threadID, Date.now() + cooldownDuration);
+    }
+
+    /**
+     * Check if an endpoint is on cooldown
+     * @param {string} endpoint - Endpoint identifier
+     * @returns {boolean}
+     */
+    isEndpointOnCooldown(endpoint) {
+        const cooldownEnd = this.endpointCooldowns.get(endpoint);
+        if (!cooldownEnd) return false;
+
+        const now = Date.now();
+        if (now >= cooldownEnd) {
+            this.endpointCooldowns.delete(endpoint);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Put an endpoint on cooldown
+     * @param {string} endpoint - Endpoint identifier
+     * @param {number} duration - Cooldown duration in milliseconds
+     */
+    setEndpointCooldown(endpoint, duration = null) {
+        const cooldownDuration = duration || this.COOLDOWN_DURATION;
+        this.endpointCooldowns.set(endpoint, Date.now() + cooldownDuration);
+    }
+
+    /**
+     * Check if an error should be suppressed from logging
+     * @param {string} key - Error cache key
+     * @returns {boolean}
+     */
+    shouldSuppressError(key) {
+        const cachedTime = this.errorCache.get(key);
+        if (!cachedTime) {
+            this.errorCache.set(key, Date.now());
+            return false;
+        }
+
+        if (Date.now() - cachedTime > this.ERROR_CACHE_TTL) {
+            this.errorCache.set(key, Date.now());
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Adaptive delay based on error type and retry count
+     * @param {number} retryCount - Current retry attempt
+     * @param {number} errorCode - Facebook error code
+     * @returns {number} Delay in milliseconds
+     */
+    getAdaptiveDelay(retryCount, errorCode = null) {
+        const baseDelays = [2000, 5000, 10000];
+
+        if (errorCode === 1545012 || errorCode === 1675004) {
+            return baseDelays[Math.min(retryCount, baseDelays.length - 1)] * 1.5;
+        }
+
+        return baseDelays[Math.min(retryCount, baseDelays.length - 1)];
+    }
+
+    /**
+     * Get current hour for circadian rhythm
+     * @returns {number}
+     */
+    getCurrentHour() {
+        return new Date().getHours();
+    }
+
+    /**
+     * Check if currently in quiet hours
+     * @returns {boolean}
+     */
+    isQuietHours() {
+        const hour = this.getCurrentHour();
+        return hour >= this.QUIET_HOURS.start && hour < this.QUIET_HOURS.end;
+    }
+
+    /**
+     * Get circadian multiplier based on time of day
+     * @returns {number}
+     */
+    getCircadianMultiplier() {
+        const hour = this.getCurrentHour();
+        if (hour >= 2 && hour < 6) return 3.0;
+        if (hour >= 0 && hour < 2) return 2.0;
+        if (hour >= 6 && hour < 9) return 1.2;
+        if (hour >= 9 && hour < 18) return 1.0;
+        if (hour >= 18 && hour < 22) return 1.1;
+        return 1.5;
+    }
+
+    /**
+     * Get context-aware delay based on conversation context
+     * @param {object} context - Request context
+     * @returns {Promise<number>}
+     */
+    async getContextAwareDelay(context = {}) {
+        const { threadID, messageType = 'text', hasAttachment = false, isReply = false } = context;
+        
+        let baseDelay = 200;
+        
+        if (hasAttachment) {
+            baseDelay += Math.random() * 1500 + 500;
+        }
+        
+        if (isReply) {
+            baseDelay += Math.random() * 300;
+        }
+        
+        const circadianMultiplier = this.getCircadianMultiplier();
+        baseDelay *= circadianMultiplier;
+        
+        if (this.checkpointMode) {
+            baseDelay *= 5;
+        }
+        
+        if (threadID && this.detectBurst(threadID)) {
+            baseDelay *= 2;
+        }
+        
+        const variance = baseDelay * 0.3;
+        const finalDelay = baseDelay + (Math.random() * variance - variance / 2);
+        
+        return Math.max(200, Math.floor(finalDelay));
+    }
+
+    /**
+     * Detect burst activity in thread
+     * @param {string} threadID
+     * @returns {boolean}
+     */
+    detectBurst(threadID) {
+        const now = Date.now();
+        const history = this.requestHistory.get(threadID) || [];
+        const recentRequests = history.filter(time => (now - time) < this.BURST_WINDOW_MS);
+        return recentRequests.length >= this.BURST_THRESHOLD;
+    }
+
+    /**
+     * Record request for burst detection
+     * @param {string} threadID
+     */
+    recordRequest(threadID) {
+        const now = Date.now();
+        const history = this.requestHistory.get(threadID) || [];
+        history.push(now);
+        const cleaned = history.filter(time => (now - time) < this.BURST_WINDOW_MS);
+        this.requestHistory.set(threadID, cleaned);
+    }
+
+    /**
+     * Track behavioral metrics
+     * @param {string} threadID
+     * @param {string} action
+     * @param {object} metadata
+     */
+    trackBehavior(threadID, action, metadata = {}) {
+        const metrics = this.behavioralMetrics.get(threadID) || {
+            messageCount: 0,
+            replyCount: 0,
+            attachmentCount: 0,
+            lastActivity: 0,
+            avgResponseTime: 0,
+            responseTimes: []
+        };
+        
+        switch (action) {
+            case 'message':
+                metrics.messageCount++;
+                break;
+            case 'reply':
+                metrics.replyCount++;
+                if (metadata.responseTime) {
+                    metrics.responseTimes.push(metadata.responseTime);
+                    if (metrics.responseTimes.length > 10) {
+                        metrics.responseTimes.shift();
+                    }
+                    metrics.avgResponseTime = metrics.responseTimes.reduce((a, b) => a + b, 0) / metrics.responseTimes.length;
+                }
+                break;
+            case 'attachment':
+                metrics.attachmentCount++;
+                break;
+        }
+        
+        metrics.lastActivity = Date.now();
+        this.behavioralMetrics.set(threadID, metrics);
+    }
+
+    /**
+     * Add stochastic delay to simulate human behavior
+     * @param {object} context - Request context
+     * @returns {Promise<void>}
+     */
+    async addStochasticDelay(context = {}) {
+        const delay = await this.getContextAwareDelay(context);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        if (context.threadID) {
+            this.recordRequest(context.threadID);
+        }
+    }
+
+    /**
+     * Add humanized delay to simulate human behavior
+     * @param {number} min - Minimum delay in milliseconds
+     * @param {number} max - Maximum delay in milliseconds
+     * @returns {Promise<void>}
+     */
+    async addHumanizedDelay(min = 200, max = 600) {
+        const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+
+    /**
+     * Enter checkpoint-aware backoff mode
+     * @param {number} duration - Duration in milliseconds
+     */
+    enterCheckpointMode(duration = 3600000) {
+        this.checkpointMode = true;
+        setTimeout(() => {
+            this.checkpointMode = false;
+        }, duration);
+    }
+
+    /**
+     * Check if can make request based on rate limiting and add humanized delay
+     * @param {boolean|object} skipHumanDelayOrContext - Skip the humanized delay if boolean, or context object
+     * @returns {Promise<void>}
+     */
+    async checkRateLimit(skipHumanDelayOrContext = false) {
+        while (this.activeRequests >= this.MAX_CONCURRENT_REQUESTS) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        const isContextObject = typeof skipHumanDelayOrContext === 'object' && skipHumanDelayOrContext !== null;
+        const skipHumanDelay = typeof skipHumanDelayOrContext === 'boolean' ? skipHumanDelayOrContext : false;
+        const context = isContextObject ? skipHumanDelayOrContext : {};
+
+        if (!skipHumanDelay) {
+            if (isContextObject) {
+                await this.addStochasticDelay(context);
+            } else {
+                await this.addHumanizedDelay();
+            }
+        }
+
+        this.activeRequests++;
+
+        setTimeout(() => {
+            this.activeRequests = Math.max(0, this.activeRequests - 1);
+        }, 1000);
+    }
+
+    /**
+     * Clear expired entries from cache
+     */
+    cleanup() {
+        const now = Date.now();
+
+        for (const [key, time] of this.errorCache.entries()) {
+            if (now - time > this.ERROR_CACHE_TTL) {
+                this.errorCache.delete(key);
+            }
+        }
+
+        for (const [key, time] of this.threadCooldowns.entries()) {
+            if (now >= time) {
+                this.threadCooldowns.delete(key);
+            }
+        }
+
+        for (const [key, time] of this.endpointCooldowns.entries()) {
+            if (now >= time) {
+                this.endpointCooldowns.delete(key);
+            }
+        }
+
+        for (const [threadID, history] of this.requestHistory.entries()) {
+            const cleaned = history.filter(time => (now - time) < this.BURST_WINDOW_MS);
+            if (cleaned.length === 0) {
+                this.requestHistory.delete(threadID);
+            } else {
+                this.requestHistory.set(threadID, cleaned);
+            }
+        }
+
+        for (const [threadID, metrics] of this.behavioralMetrics.entries()) {
+            if ((now - metrics.lastActivity) > 3600000) {
+                this.behavioralMetrics.delete(threadID);
+            }
+        }
+    }
+
+    /**
+     * Get cooldown remaining time for thread
+     * @param {string} threadID - Thread identifier
+     * @returns {number} Remaining milliseconds
+     */
+    getCooldownRemaining(threadID) {
+        const cooldownEnd = this.threadCooldowns.get(threadID);
+        if (!cooldownEnd) return 0;
+        return Math.max(0, cooldownEnd - Date.now());
+    }
+
+    /**
+     * Get cooldown remaining time for endpoint
+     * @param {string} endpoint - Endpoint identifier
+     * @returns {number} Remaining milliseconds
+     */
+    getEndpointCooldownRemaining(endpoint) {
+        const cooldownEnd = this.endpointCooldowns.get(endpoint);
+        if (!cooldownEnd) return 0;
+        return Math.max(0, cooldownEnd - Date.now());
+    }
+}
+
+const globalRateLimiter = new RateLimiter();
+
+setInterval(() => globalRateLimiter.cleanup(), 60000);
+
+module.exports = {
+    RateLimiter,
+    globalRateLimiter
+};

package/src/utils/tokenRefresh.js

@@ -0,0 +1,311 @@
+"use strict";
+
+const utils = require('./index');
+
+/**
+ * Token Refresh Manager
+ * Automatically refreshes fb_dtsg, lsd, and other tokens to prevent expiration
+ */
+
+class TokenRefreshManager {
+    constructor() {
+        this.refreshInterval = null;
+        this.REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+        this.lastRefresh = Date.now();
+        this.failureCount = 0;
+        this.MAX_FAILURES = 3;
+        this.onSessionExpiry = null;
+        this.onCheckpointDetected = null;
+        this.autoReLoginManager = null;
+        this.api = null;
+        this.fbLink = null;
+        this.ERROR_RETRIEVING = null;
+    }
+
+    /**
+     * Start automatic token refresh
+     * @param {Object} ctx - Application context
+     * @param {Object} defaultFuncs - Default functions
+     * @param {string} fbLink - Facebook link
+     */
+    startAutoRefresh(ctx, defaultFuncs, fbLink) {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+        }
+
+        this.refreshInterval = setInterval(async () => {
+            try {
+                await this.refreshTokens(ctx, defaultFuncs, fbLink);
+                utils.log("TokenRefresh", "Tokens refreshed successfully");
+            } catch (error) {
+                utils.error("TokenRefresh", "Failed to refresh tokens:", error.message);
+            }
+        }, this.REFRESH_INTERVAL_MS);
+
+        utils.log("TokenRefresh", "Auto-refresh enabled (every 24 hours)");
+    }
+
+    /**
+     * Set API and link references for auto-relogin
+     * @param {Object} api - API instance
+     * @param {string} fbLink - Facebook link
+     * @param {string} ERROR_RETRIEVING - Error message
+     */
+    setAPIReferences(api, fbLink, ERROR_RETRIEVING) {
+        this.api = api;
+        this.fbLink = fbLink;
+        this.ERROR_RETRIEVING = ERROR_RETRIEVING;
+    }
+
+    /**
+     * Detect checkpoint or session errors with specific markers
+     * @param {string} html - HTML response
+     * @param {Error} error - Error object
+     * @param {string} responseUrl - Response URL for redirect detection
+     * @returns {object} Detection result
+     */
+    detectCheckpoint(html, error, responseUrl = null) {
+        if (responseUrl) {
+            if (responseUrl.includes('/checkpoint/') || responseUrl.includes('/login/') || responseUrl.includes('/login.php')) {
+                return { detected: true, type: 'url_redirect' };
+            }
+        }
+        
+        if (html) {
+            if (html.includes('id="checkpoint_') || html.includes('name="checkpoint"')) {
+                return { detected: true, type: 'checkpoint_form' };
+            }
+            
+            if (html.includes('id="login_form"') && html.includes('name="email"') && html.includes('name="pass"')) {
+                return { detected: true, type: 'login_page' };
+            }
+            
+            if (html.includes('security check') && html.includes('verify')) {
+                return { detected: true, type: 'security_checkpoint' };
+            }
+            
+            if (html.includes('session has expired') || html.includes('Please log in')) {
+                return { detected: true, type: 'session_expired' };
+            }
+        }
+        
+        if (error && error.message) {
+            const errorMsg = error.message.toLowerCase();
+            if (errorMsg.includes('checkpoint')) {
+                return { detected: true, type: 'error_checkpoint' };
+            }
+            if (errorMsg.includes('session expired') || errorMsg.includes('session_expired')) {
+                return { detected: true, type: 'error_session_expired' };
+            }
+            if (errorMsg.includes('invalid session') || errorMsg.includes('invalid_session')) {
+                return { detected: true, type: 'error_invalid_session' };
+            }
+        }
+        
+        return { detected: false, type: null };
+    }
+
+    /**
+     * Manually refresh tokens with retry logic
+     * @param {Object} ctx - Application context
+     * @param {Object} defaultFuncs - Default functions
+     * @param {string} fbLink - Facebook link
+     * @param {number} retryCount - Current retry attempt (internal use)
+     * @returns {Promise<boolean>}
+     */
+    async refreshTokens(ctx, defaultFuncs, fbLink, retryCount = 0) {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAYS = [2000, 5000, 10000];
+        
+        try {
+            const resp = await utils.get(fbLink, ctx.jar, null, ctx.globalOptions, { noRef: true });
+            
+            const html = resp.body;
+            const responseUrl = resp.request && resp.request.uri ? resp.request.uri.href : null;
+            
+            if (!html) {
+                throw new Error("Empty response from Facebook");
+            }
+
+            const checkpoint = this.detectCheckpoint(html, null, responseUrl);
+            if (checkpoint.detected) {
+                utils.warn("TokenRefresh", `Checkpoint detected: ${checkpoint.type}`);
+                
+                if (this.onCheckpointDetected && typeof this.onCheckpointDetected === 'function') {
+                    this.onCheckpointDetected(checkpoint.type);
+                }
+                
+                if (this.autoReLoginManager && this.autoReLoginManager.isEnabled() && this.api) {
+                    utils.log("TokenRefresh", "Triggering auto-relogin due to checkpoint...");
+                    const reloginSuccess = await this.attemptRelogin(this.api, this.fbLink, this.ERROR_RETRIEVING);
+                    if (reloginSuccess) {
+                        return true;
+                    }
+                }
+                
+                throw new Error(`Checkpoint required: ${checkpoint.type}`);
+            }
+
+            const dtsgMatch = html.match(/"DTSGInitialData",\[],{"token":"([^"]+)"/);
+            if (dtsgMatch) {
+                ctx.fb_dtsg = dtsgMatch[1];
+                ctx.ttstamp = "2";
+                for (let i = 0; i < ctx.fb_dtsg.length; i++) {
+                    ctx.ttstamp += ctx.fb_dtsg.charCodeAt(i);
+                }
+            } else {
+                throw new Error("Failed to extract fb_dtsg token");
+            }
+
+            const lsdMatch = html.match(/"LSD",\[],{"token":"([^"]+)"/);
+            if (lsdMatch) {
+                ctx.lsd = lsdMatch[1];
+            }
+
+            const jazoestMatch = html.match(/jazoest=(\d+)/);
+            if (jazoestMatch) {
+                ctx.jazoest = jazoestMatch[1];
+            }
+
+            const revisionMatch = html.match(/"client_revision":(\d+)/);
+            if (revisionMatch) {
+                ctx.__rev = revisionMatch[1];
+            }
+
+            this.lastRefresh = Date.now();
+            this.failureCount = 0;
+            return true;
+        } catch (error) {
+            this.failureCount++;
+            utils.error("TokenRefresh", `Refresh failed (attempt ${retryCount + 1}/${MAX_RETRIES + 1}):`, error.message);
+            
+            const checkpoint = this.detectCheckpoint(null, error);
+            if (checkpoint.detected) {
+                utils.warn("TokenRefresh", `Checkpoint detected in error: ${checkpoint.type}`);
+                
+                if (this.onCheckpointDetected && typeof this.onCheckpointDetected === 'function') {
+                    this.onCheckpointDetected(checkpoint.type);
+                }
+            }
+            
+            if (this.failureCount >= this.MAX_FAILURES) {
+                utils.error("TokenRefresh", `Maximum failures (${this.MAX_FAILURES}) reached. Session may be expired.`);
+                if (this.onSessionExpiry && typeof this.onSessionExpiry === 'function') {
+                    this.onSessionExpiry(error);
+                }
+                return false;
+            }
+            
+            if (retryCount < MAX_RETRIES) {
+                const delay = RETRY_DELAYS[retryCount];
+                utils.log("TokenRefresh", `Retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return await this.refreshTokens(ctx, defaultFuncs, fbLink, retryCount + 1);
+            }
+            
+            return false;
+        }
+    }
+
+    /**
+     * Set auto-relogin manager reference
+     * @param {Object} autoReLoginManager - AutoReLoginManager instance
+     */
+    setAutoReLoginManager(autoReLoginManager) {
+        this.autoReLoginManager = autoReLoginManager;
+    }
+
+    /**
+     * Attempt auto-relogin using the AutoReLoginManager
+     * @param {Object} api - API instance
+     * @param {string} fbLink - Facebook link
+     * @param {string} ERROR_RETRIEVING - Error message for retrieving
+     * @returns {Promise<boolean>}
+     */
+    async attemptRelogin(api, fbLink, ERROR_RETRIEVING) {
+        try {
+            if (!this.autoReLoginManager || !this.autoReLoginManager.isEnabled()) {
+                utils.warn("TokenRefresh", "AutoReLoginManager not available or not enabled");
+                return false;
+            }
+            
+            utils.log("TokenRefresh", "Triggering auto-relogin via AutoReLoginManager");
+            const success = await this.autoReLoginManager.handleSessionExpiry(api, fbLink, ERROR_RETRIEVING);
+            
+            if (success) {
+                this.resetFailureCount();
+                utils.log("TokenRefresh", "Auto-relogin completed successfully");
+                return true;
+            } else {
+                utils.error("TokenRefresh", "Auto-relogin failed");
+                return false;
+            }
+        } catch (error) {
+            utils.error("TokenRefresh", "Auto-relogin error:", error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Set callback for checkpoint detection
+     * @param {Function} callback - Callback function to trigger on checkpoint
+     */
+    setCheckpointCallback(callback) {
+        this.onCheckpointDetected = callback;
+    }
+
+    /**
+     * Stop automatic token refresh
+     */
+    stopAutoRefresh() {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+            this.refreshInterval = null;
+            utils.log("TokenRefresh", "Auto-refresh disabled");
+        }
+    }
+
+    /**
+     * Get time until next refresh
+     * @returns {number} Milliseconds until next refresh
+     */
+    getTimeUntilNextRefresh() {
+        if (!this.refreshInterval) return -1;
+        return Math.max(0, this.REFRESH_INTERVAL_MS - (Date.now() - this.lastRefresh));
+    }
+
+    /**
+     * Check if tokens need immediate refresh
+     * @returns {boolean}
+     */
+    needsImmediateRefresh() {
+        return (Date.now() - this.lastRefresh) >= this.REFRESH_INTERVAL_MS;
+    }
+
+    /**
+     * Set callback for session expiry detection
+     * @param {Function} callback - Callback function to trigger on session expiry
+     */
+    setSessionExpiryCallback(callback) {
+        this.onSessionExpiry = callback;
+    }
+
+    /**
+     * Reset failure count (useful after successful re-login)
+     */
+    resetFailureCount() {
+        this.failureCount = 0;
+    }
+
+    /**
+     * Get current failure count
+     * @returns {number}
+     */
+    getFailureCount() {
+        return this.failureCount;
+    }
+}
+
+module.exports = {
+    TokenRefreshManager
+};