@lazyneoaz/testfca 1.0.0

package/src/utils/axios.js

@@ -0,0 +1,436 @@
+/* eslint-disable no-prototype-builtins */
+"use strict";
+
+const axios = require("axios");
+const { CookieJar } = require("tough-cookie");
+const { wrapper } = require("axios-cookiejar-support");
+const FormData = require("form-data");
+const { getHeaders } = require("./headers");
+const { getType } = require("./constants");
+const { globalRateLimiter } = require("./rateLimiter");
+
+const jar = new CookieJar();
+const client = wrapper(axios.create({ jar }));
+
+let proxyConfig = {};
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+// Fast path for simple delays - use setImmediate for 0ms delays
+const fastDelay = (ms) => {
+    if (ms <= 0) return Promise.resolve();
+    if (ms <= 1) return new Promise(resolve => setImmediate(resolve));
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+function adaptResponse(res) {
+    const response = res.response || res;
+    return {
+        ...response,
+        body: response.data,
+        statusCode: response.status,
+        request: {
+            uri: new URL(response.config.url),
+            headers: response.config.headers,
+            method: response.config.method.toUpperCase(),
+            form: response.config.data,
+            formData: response.config.data
+        },
+    };
+}
+
+/**
+ * Inspects an API response body for signs of session expiry or Facebook
+ * bot-detection checkpoints and emits the appropriate signals on ctx.
+ *
+ * Returns true if the response looks like a valid authenticated response,
+ * false if it signals logout / checkpoint.
+ *
+ * When a logout is detected and ctx.performAutoLogin is available the
+ * function fires it (non-blocking) and throws so the caller knows the
+ * original response is unusable.
+ */
+async function inspectResponseForSessionIssues(adapted, ctx) {
+    if (!ctx || ctx._skipSessionInspect) return;
+
+    const body = adapted.body;
+    if (!body) return;
+
+    const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+
+    // Facebook bot-detection checkpoint IDs
+    const isCheckpoint282 = bodyStr.includes('1501092823525282');
+    const isCheckpoint956 = bodyStr.includes('828281030927956');
+    const isScrapingWarning = bodyStr.includes('XCheckpointFBScrapingWarningController');
+
+    if (isCheckpoint282) {
+        const err = new Error('Bot checkpoint 282 detected. Please verify the account.');
+        err.error = 'checkpoint_282';
+        err.res = body;
+        if (ctx._emitter && typeof ctx._emitter.emit === 'function') {
+            ctx._emitter.emit('checkpoint_282', { res: body });
+        }
+        throw err;
+    }
+
+    if (isCheckpoint956) {
+        const err = new Error('Bot checkpoint 956 detected. Please verify the account.');
+        err.error = 'checkpoint_956';
+        err.res = body;
+        if (ctx._emitter && typeof ctx._emitter.emit === 'function') {
+            ctx._emitter.emit('checkpoint_956', { res: body });
+        }
+        throw err;
+    }
+
+    if (isScrapingWarning) {
+        const err = new Error('Facebook scraping warning checkpoint detected.');
+        err.error = 'checkpoint_scraping';
+        err.res = body;
+        if (ctx._emitter && typeof ctx._emitter.emit === 'function') {
+            ctx._emitter.emit('checkpoint', { type: 'scraping_warning', res: body });
+        }
+        throw err;
+    }
+
+    // Detect session expiry / forced logout.
+    // IMPORTANT: Facebook's authenticated homepage also contains login.php links
+    // in its nav/footer and has <title>Facebook</title> — any broad HTML-content
+    // check will produce false positives and break valid sessions.
+    // We ONLY flag a response as a login redirect when:
+    //   • The page contains the actual login form elements, OR
+    //   • A parsed JSON body explicitly redirects to login.php via a "redirect" field.
+    const isLoginRedirect =
+        bodyStr.includes('<form id="login_form"') ||
+        bodyStr.includes('id="loginbutton"') ||
+        bodyStr.includes('"login_page"') ||
+        // JSON responses that carry an explicit redirect to the login page.
+        // "next" appears alongside login.php only in unauthenticated redirect payloads.
+        (bodyStr.includes('login.php') && bodyStr.includes('"next":"'));
+
+    const isLoginBlocked =
+        typeof body === 'object' && body !== null && body.error === 1357001;
+
+    if (isLoginBlocked) {
+        const err = new Error('Facebook blocked the login.');
+        err.error = 'login_blocked';
+        err.res = body;
+        throw err;
+    }
+
+    if (isLoginRedirect) {
+        if (ctx._emitter && typeof ctx._emitter.emit === 'function') {
+            ctx._emitter.emit('sessionExpired', { res: body });
+        }
+
+        if (!ctx.auto_login && typeof ctx.performAutoLogin === 'function') {
+            ctx.auto_login = true;
+            // Safety: reset the flag after 2 minutes no matter what so future
+            // session expiries are never silently swallowed.
+            const autoLoginSafetyTimer = setTimeout(() => { ctx.auto_login = false; }, 120000);
+            try {
+                const ok = await ctx.performAutoLogin();
+                clearTimeout(autoLoginSafetyTimer);
+                ctx.auto_login = false;
+                if (!ok) {
+                    const err = new Error('Not logged in. Auto re-login failed.');
+                    err.error = 'Not logged in.';
+                    err.res = body;
+                    throw err;
+                }
+            } catch (autoErr) {
+                clearTimeout(autoLoginSafetyTimer);
+                ctx.auto_login = false;
+                throw autoErr;
+            }
+        } else {
+            const err = new Error('Not logged in. Session has expired.');
+            err.error = 'Not logged in.';
+            err.res = body;
+            throw err;
+        }
+    }
+}
+
+async function requestWithRetry(requestFunction, retries = 5, endpoint = '', threadID = '', ctx = null) {
+    // Fast path for simple requests
+    const isSimpleRequest = !endpoint && !threadID;
+    
+    // Acquire rate limit slot with optimized path
+    let releaseSlot = null;
+    if (!isSimpleRequest) {
+        releaseSlot = await globalRateLimiter.checkRateLimit(false, endpoint);
+    }
+
+    // Check cooldowns efficiently
+    if (!isSimpleRequest) {
+        if (globalRateLimiter.isEndpointOnCooldown("__GLOBAL__")) {
+            const cooldown = globalRateLimiter.getEndpointCooldownRemaining("__GLOBAL__");
+            if (cooldown > 0) {
+                console.warn(`Global cooldown active. Waiting ${cooldown}ms...`);
+                await delay(cooldown);
+            }
+        }
+
+        if (endpoint && globalRateLimiter.isEndpointOnCooldown(endpoint)) {
+            const cooldown = globalRateLimiter.getEndpointCooldownRemaining(endpoint);
+            if (cooldown > 0) {
+                console.warn(`Endpoint ${endpoint} on cooldown. Waiting ${cooldown}ms...`);
+                await delay(cooldown);
+            }
+        }
+
+        if (threadID && globalRateLimiter.isThreadOnCooldown(threadID)) {
+            const cooldown = globalRateLimiter.getCooldownRemaining(threadID);
+            if (cooldown > 0) {
+                console.warn(`Thread ${threadID} on cooldown. Waiting ${cooldown}ms...`);
+                await delay(cooldown);
+            }
+        }
+    }
+
+    const checkAndApplyRateLimitCooldowns = (responseBody) => {
+        const ERROR_COOLDOWNS = {
+            1545012: 60000,
+            1675004: 30000,
+            368: 120000,
+            404: 5000,
+            500: 10000,
+            503: 30000
+        };
+
+        const applyCooldown = (errorCode) => {
+            if (errorCode && ERROR_COOLDOWNS[errorCode]) {
+                if (threadID) {
+                    globalRateLimiter.setThreadCooldown(threadID, ERROR_COOLDOWNS[errorCode]);
+                }
+                if (endpoint) {
+                    globalRateLimiter.setEndpointCooldown(endpoint, ERROR_COOLDOWNS[errorCode]);
+                }
+                console.warn(`Rate limit detected (error ${errorCode}). Applied cooldown.`);
+                return true;
+            }
+            return false;
+        };
+
+        if (!responseBody || typeof responseBody !== 'object') {
+            return false;
+        }
+
+        if (applyCooldown(responseBody.error)) {
+            return true;
+        }
+
+        if (Array.isArray(responseBody)) {
+            for (const item of responseBody) {
+                if (item && typeof item === 'object') {
+                    if (applyCooldown(item.error)) return true;
+                    if (item.errors && Array.isArray(item.errors)) {
+                        for (const err of item.errors) {
+                            const code = err.code || err.extensions?.code;
+                            if (applyCooldown(code)) return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (responseBody.errors && Array.isArray(responseBody.errors)) {
+            for (const err of responseBody.errors) {
+                const code = err.code || err.extensions?.code;
+                if (applyCooldown(code)) return true;
+            }
+        }
+
+        return false;
+    };
+
+    try {
+        for (let i = 0; i < retries; i++) {
+            try {
+                const res = await requestFunction();
+                const adapted = adaptResponse(res);
+
+                checkAndApplyRateLimitCooldowns(adapted.body);
+
+                // Inspect for session expiry / bot-detection checkpoints
+                await inspectResponseForSessionIssues(adapted, ctx);
+
+                return adapted;
+            } catch (error) {
+                // If this is a session/checkpoint error we already raised, propagate immediately
+                if (error.error === 'Not logged in.' ||
+                    error.error === 'checkpoint_282' ||
+                    error.error === 'checkpoint_956' ||
+                    error.error === 'checkpoint_scraping' ||
+                    error.error === 'login_blocked') {
+                    throw error;
+                }
+
+                // Abort immediately on invalid header characters - retrying won't help
+                if (error.code === 'ERR_INVALID_CHAR' ||
+                    (error.message && error.message.includes('Invalid character in header'))) {
+                    const e = new Error('Invalid header content detected. Request aborted.');
+                    e.error = 'invalid_header';
+                    e.code = 'ERR_INVALID_CHAR';
+                    e.originalError = error;
+                    throw e;
+                }
+
+                // Network errors - might be transient
+                const isNetworkError = error.code && [
+                    'ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'ENETUNREACH',
+                    'EHOSTUNREACH', 'EAI_AGAIN', 'ENOTFOUND', 'ESOCKETTIMEDOUT'
+                ].includes(error.code);
+
+                if (error.response) {
+                    const adapted = adaptResponse(error.response);
+                    checkAndApplyRateLimitCooldowns(adapted.body);
+                }
+
+                if (i === retries - 1) {
+                    console.error(`Request failed after ${retries} attempts:`, error.message);
+                    if (error.response) {
+                        return adaptResponse(error.response);
+                    }
+                    throw error;
+                }
+                
+                // Adaptive backoff: network errors get shorter delays
+                const baseMultiplier = isNetworkError ? 0.5 : 1;
+                const backoffTime = Math.min(
+                    (Math.pow(2, i) * 1000 * baseMultiplier) + Math.floor(Math.random() * 1000),
+                    30000 // Cap at 30 seconds
+                );
+                
+                if (backoffTime > 100) {
+                    console.warn(`Request attempt ${i + 1} failed. Retrying in ${Math.round(backoffTime)}ms...`);
+                    await delay(backoffTime);
+                } else {
+                    // Fast path for very short delays
+                    await fastDelay(backoffTime);
+                }
+            }
+        }
+    } finally {
+        // Always release the concurrency slot regardless of outcome.
+        if (typeof releaseSlot === 'function') releaseSlot();
+    }
+}
+
+function setProxy(proxyUrl) {
+    if (proxyUrl) {
+        try {
+            const parsedProxy = new URL(proxyUrl);
+            proxyConfig = {
+                proxy: {
+                    host: parsedProxy.hostname,
+                    port: parsedProxy.port,
+                    protocol: parsedProxy.protocol.replace(":", ""),
+                    auth: parsedProxy.username && parsedProxy.password ? {
+                        username: parsedProxy.username,
+                        password: parsedProxy.password,
+                    } : undefined,
+                },
+            };
+        } catch (e) {
+            console.error("Invalid proxy URL. Please use a full URL format (e.g., http://user:pass@host:port).");
+            proxyConfig = {};
+        }
+    } else {
+        proxyConfig = {};
+    }
+}
+
+function cleanGet(url) {
+    const fn = () => client.get(url, { timeout: 60000, ...proxyConfig });
+    return requestWithRetry(fn);
+}
+
+async function get(url, reqJar, qs, options, ctx, customHeader) {
+    const config = {
+        headers: getHeaders(url, options, ctx, customHeader),
+        timeout: 60000,
+        params: qs,
+        ...proxyConfig,
+        validateStatus: (status) => status >= 200 && status < 600,
+        // Enable response compression for faster transfers
+        decompress: true,
+        // Optimize for performance
+        maxContentLength: 50 * 1024 * 1024, // 50MB max
+        maxBodyLength: 50 * 1024 * 1024
+    };
+    const endpoint = new URL(url).pathname;
+    const threadHint = ctx && ctx.requestThreadID ? String(ctx.requestThreadID) : '';
+    return requestWithRetry(async () => await client.get(url, config), 3, endpoint, threadHint, ctx);
+}
+
+async function post(url, reqJar, form, options, ctx, customHeader) {
+    const headers = getHeaders(url, options, ctx, customHeader, 'xhr');
+    let data = form;
+    let contentType = headers['Content-Type'] || 'application/x-www-form-urlencoded';
+
+    if (contentType.includes('json')) {
+        data = JSON.stringify(form);
+    } else {
+        // Use URLSearchParams for better performance on large forms
+        const transformedForm = new URLSearchParams();
+        for (const key in form) {
+            if (form.hasOwnProperty(key)) {
+                let value = form[key];
+                if (getType(value) === "Object") {
+                    value = JSON.stringify(value);
+                }
+                transformedForm.append(key, value);
+            }
+        }
+        data = transformedForm.toString();
+    }
+
+    headers['Content-Type'] = contentType;
+
+    const config = {
+        headers,
+        timeout: 60000,
+        ...proxyConfig,
+        validateStatus: (status) => status >= 200 && status < 600,
+        decompress: true,
+        maxContentLength: 50 * 1024 * 1024,
+        maxBodyLength: 50 * 1024 * 1024
+    };
+    const endpoint = new URL(url).pathname;
+    const threadHint = ctx && ctx.requestThreadID ? String(ctx.requestThreadID) : '';
+    return requestWithRetry(async () => await client.post(url, data, config), 3, endpoint, threadHint, ctx);
+}
+
+async function postFormData(url, reqJar, form, qs, options, ctx) {
+    const formData = new FormData();
+    for (const key in form) {
+        if (form.hasOwnProperty(key)) {
+            formData.append(key, form[key]);
+        }
+    }
+
+    const customHeader = { "Content-Type": `multipart/form-data; boundary=${formData.getBoundary()}` };
+
+    const config = {
+        headers: getHeaders(url, options, ctx, customHeader, 'xhr'),
+        timeout: 60000,
+        params: qs,
+        ...proxyConfig,
+        validateStatus: (status) => status >= 200 && status < 600,
+    };
+    const endpoint = new URL(url).pathname;
+    const threadHint = ctx && ctx.requestThreadID ? String(ctx.requestThreadID) : '';
+    return requestWithRetry(async () => await client.post(url, formData, config), 3, endpoint, threadHint, ctx);
+}
+
+module.exports = {
+  cleanGet,
+  get,
+  post,
+  postFormData,
+  getJar: () => jar,
+  setProxy,
+  requestWithRetry
+};

package/src/utils/cache.js

@@ -0,0 +1,54 @@
+"use strict";
+
+class SimpleCache {
+  constructor(defaultTTL = 300000) { // 5 minutes default
+    this.cache = new Map();
+    this.defaultTTL = defaultTTL;
+  }
+
+  set(key, value, ttl = this.defaultTTL) {
+    const expiresAt = Date.now() + ttl;
+    this.cache.set(key, { value, expiresAt });
+
+    // Clean up expired entries occasionally
+    if (Math.random() < 0.01) { // 1% chance
+      this.cleanup();
+    }
+  }
+
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+
+    if (Date.now() > item.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    return item.value;
+  }
+
+  delete(key) {
+    return this.cache.delete(key);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [key, item] of this.cache.entries()) {
+      if (now > item.expiresAt) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  size() {
+    this.cleanup();
+    return this.cache.size;
+  }
+}
+
+module.exports = SimpleCache;