@lazyneoaz/nkxchat 1.0.0

package/src/utils/autoReLogin.js

@@ -0,0 +1,237 @@
+"use strict";
+
+const utils = require('./index');
+
+class AutoReLoginManager {
+    constructor() {
+        this.credentials = null;
+        this.loginOptions = null;
+        this.loginCallback = null;
+        this.isReLoggingIn = false;
+        this.pendingRequests = [];
+        this.maxRetries = 3; // Reduced: too many re-logins look highly suspicious to Facebook
+        this.retryCount = 0;
+        this.onReLoginSuccess = null;
+        this.onReLoginFailure = null;
+        this.enabled = false;
+        this.reLoginInterval = 1000 * 60 * 60 * 24; // 24 hours
+        this.sessionMonitorInterval = null;
+        // Removed separate 15-minute session polling - tokenRefresh already handles this.
+        // Duplicate polling from two systems every 15-30 min looked like bot traffic to Facebook.
+        this.sessionCheckInterval = 1000 * 60 * 120; // 2 hours
+    }
+
+    setCredentials(credentials, options, callback) {
+        this.credentials = credentials;
+        this.loginOptions = options || {};
+        this.loginCallback = callback;
+        this.enabled = true;
+        // Reset retry counter on fresh credential set so old failures
+        // from a previous session do not permanently lock re-login.
+        this.retryCount = 0;
+        // Do NOT call startSessionMonitoring() here — the api object is not
+        // available yet. loginHelper calls startSessionMonitoring(api) once
+        // all api methods are registered.
+    }
+
+    startSessionMonitoring(api) {
+        if (this.sessionMonitorInterval) {
+            clearInterval(this.sessionMonitorInterval);
+        }
+
+        if (!this.enabled || !api) return;
+
+        this.sessionMonitorInterval = setInterval(async () => {
+            if (this.isReLoggingIn) return; // Skip if already re-logging in
+
+            try {
+                const isValid = await api.isSessionValid();
+                if (!isValid) {
+                    utils.warn("AutoReLogin", "Session health check failed, triggering automatic re-login");
+                    await this.handleSessionExpiry(api, 'https://www.facebook.com', "Session expired during monitoring");
+                }
+            } catch (error) {
+                utils.error("AutoReLogin", "Session monitoring error:", error.message);
+            }
+        }, this.sessionCheckInterval);
+
+        utils.log("AutoReLogin", `Session monitoring started (interval: ${this.sessionCheckInterval}ms)`);
+    }
+
+    stopSessionMonitoring() {
+        if (this.sessionMonitorInterval) {
+            clearInterval(this.sessionMonitorInterval);
+            this.sessionMonitorInterval = null;
+            utils.log("AutoReLogin", "Session monitoring stopped");
+        }
+    }
+
+    isEnabled() {
+        return this.enabled && this.credentials !== null;
+    }
+
+    async handleSessionExpiry(api, fbLink, ERROR_RETRIEVING) {
+        if (!this.isEnabled()) {
+            utils.warn("AutoReLogin", "Auto re-login not enabled. Credentials not stored.");
+            return false;
+        }
+
+        if (this.isReLoggingIn) {
+            utils.log("AutoReLogin", "Re-login already in progress. Queuing request...");
+            return new Promise((resolve, reject) => {
+                this.pendingRequests.push({ resolve, reject });
+            });
+        }
+
+        if (this.retryCount >= this.maxRetries) {
+            utils.error("AutoReLogin", `Maximum re-login attempts (${this.maxRetries}) exceeded`);
+            if (this.onReLoginFailure) {
+                this.onReLoginFailure(new Error("Max re-login retries exceeded"));
+            }
+            return false;
+        }
+
+        this.isReLoggingIn = true;
+        this.retryCount++;
+        utils.log("AutoReLogin", `Starting automatic re-login (attempt ${this.retryCount}/${this.maxRetries})...`);
+
+        try {
+            await this.pauseAPIRequests();
+
+            const loginHelperModel = require('../engine/models/loginHelper');
+            const setOptionsModel = require('../engine/models/setOptions');
+            const buildAPIModel = require('../engine/models/buildAPI');
+
+            await new Promise((resolve, reject) => {
+                loginHelperModel(
+                    this.credentials,
+                    this.loginOptions,
+                    (loginError, newApi) => {
+                        if (loginError) {
+                            reject(loginError);
+                            return;
+                        }
+                        
+                        if (api) {
+                            api.ctx = newApi.ctx;
+                            api.defaultFuncs = newApi.defaultFuncs;
+                            
+                            if (api.tokenRefreshManager) {
+                                api.tokenRefreshManager.resetFailureCount();
+                            }
+                        }
+                        
+                        resolve(newApi);
+                    },
+                    setOptionsModel,
+                    buildAPIModel,
+                    api,
+                    fbLink,
+                    ERROR_RETRIEVING
+                );
+            });
+
+            utils.log("AutoReLogin", "Re-login successful! Session restored.");
+            this.retryCount = 0;
+            this.isReLoggingIn = false;
+
+            this.resolvePendingRequests(true);
+
+            if (this.onReLoginSuccess) {
+                this.onReLoginSuccess();
+            }
+
+            try {
+                if (api && api.listenMqtt && api.ctx && api.ctx._listeningActive) {
+                    try {
+                        if (typeof api.stopListening === 'function') {
+                            try { api.stopListening(); } catch (_) {}
+                        }
+                        const cb = api.ctx._lastListenCallback || null;
+                        if (cb) {
+                            api.listenMqtt(cb);
+                        } else {
+                            api.listenMqtt();
+                        }
+                    } catch (_) {}
+                }
+            } catch (_) {}
+
+            return true;
+        } catch (error) {
+            utils.error("AutoReLogin", `Re-login failed:`, error.message);
+            this.isReLoggingIn = false;
+
+            if (this.retryCount >= this.maxRetries) {
+                this.resolvePendingRequests(false);
+                if (this.onReLoginFailure) {
+                    this.onReLoginFailure(error);
+                }
+                return false;
+            }
+
+            const backoffDelay = Math.min(30000, Math.pow(2, this.retryCount) * 1000);
+            utils.log("AutoReLogin", `Retrying re-login in ${backoffDelay}ms...`);
+            await new Promise(resolve => setTimeout(resolve, backoffDelay));
+
+            return await this.handleSessionExpiry(api, fbLink, ERROR_RETRIEVING);
+        }
+    }
+
+    async pauseAPIRequests() {
+        utils.log("AutoReLogin", "Pausing API requests during re-login...");
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    resolvePendingRequests(success) {
+        utils.log("AutoReLogin", `Resolving ${this.pendingRequests.length} pending requests (success: ${success})`);
+        
+        this.pendingRequests.forEach(({ resolve, reject }) => {
+            if (success) {
+                resolve(true);
+            } else {
+                reject(new Error("Re-login failed"));
+            }
+        });
+        
+        this.pendingRequests = [];
+    }
+
+    setReLoginSuccessCallback(callback) {
+        this.onReLoginSuccess = callback;
+    }
+
+    setReLoginFailureCallback(callback) {
+        this.onReLoginFailure = callback;
+    }
+
+    updateAppState(appState) {
+        if (!this.credentials) return;
+        if (!Array.isArray(appState) || appState.length === 0) return;
+        if (!this.credentials.appState || Array.isArray(this.credentials.appState) || typeof this.credentials.appState === "string") {
+            this.credentials.appState = appState;
+        }
+    }
+
+    disable() {
+        this.enabled = false;
+        this.stopSessionMonitoring();
+        this.credentials = null;
+        this.loginOptions = null;
+        this.loginCallback = null;
+        utils.log("AutoReLogin", "Auto re-login disabled and credentials cleared");
+    }
+
+    reset() {
+        this.retryCount = 0;
+        this.isReLoggingIn = false;
+        this.pendingRequests = [];
+    }
+}
+
+const globalAutoReLoginManager = new AutoReLoginManager();
+
+module.exports = {
+    AutoReLoginManager,
+    globalAutoReLoginManager
+};

package/src/utils/axios.js

@@ -0,0 +1,368 @@
+/* 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));
+
+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
+    const isLoginRedirect =
+        bodyStr.includes('"login.php?') ||
+        bodyStr.includes('https://www.facebook.com/login.php') ||
+        bodyStr.includes('<form id="login_form"') ||
+        bodyStr.includes('id="loginbutton"') ||
+        bodyStr.includes('"login_page"');
+
+    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;
+            try {
+                const ok = await ctx.performAutoLogin();
+                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) {
+                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) {
+    await globalRateLimiter.checkRateLimit();
+
+    if (globalRateLimiter.isEndpointOnCooldown("__GLOBAL__")) {
+        const cooldown = globalRateLimiter.getEndpointCooldownRemaining("__GLOBAL__");
+        console.warn(`Global cooldown active. Waiting ${cooldown}ms...`);
+        await delay(cooldown);
+    }
+
+    if (endpoint && globalRateLimiter.isEndpointOnCooldown(endpoint)) {
+        const cooldown = globalRateLimiter.getEndpointCooldownRemaining(endpoint);
+        console.warn(`Endpoint ${endpoint} on cooldown. Waiting ${cooldown}ms...`);
+        await delay(cooldown);
+    }
+
+    if (threadID && globalRateLimiter.isThreadOnCooldown(threadID)) {
+        const cooldown = globalRateLimiter.getCooldownRemaining(threadID);
+        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;
+    };
+
+    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;
+            }
+
+            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;
+            }
+            const backoffTime = (Math.pow(2, i)) * 1000 + Math.floor(Math.random() * 1000);
+            console.warn(`Request attempt ${i + 1} failed. Retrying in ${backoffTime}ms...`);
+            await delay(backoffTime);
+        }
+    }
+}
+
+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,
+    };
+    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 {
+        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,
+    };
+    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,
+};

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;