shadowx-fca 2.1.0 → 2.3.0

package/README.md

@@ -0,0 +1,449 @@
+```markdown
+# shadowx-fca
+#Mueid Mursalin Rifat
+
+<p align="center">
+  <strong>Unofficial Facebook Chat API for Node.js with Auto-Update System</strong><br>
+  Modified by Mueid Mursalin Rifat | Original by shadowX
+</p>
+
+## 📋 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Quick Start](#-quick-start)
+- [Authentication Methods](#-authentication-methods)
+- [API Documentation](#-api-documentation)
+- [Configuration](#-configuration)
+- [Anti-Detection Features](#-anti-detection-features)
+- [Troubleshooting](#-troubleshooting)
+- [Examples](#-examples)
+- [Changelog](#-changelog)
+- [License](#-license)
+
+## ✨ Features
+
+- ✅ **Multiple Authentication Methods** - Support for both appState and email/password login
+- ✅ **Real-time Messaging** - MQTT/WebSocket based real-time message listening
+- ✅ **Auto-Update System** - Automatically checks and updates to latest version
+- ✅ **Anti-Detection** - Rotating user agents, rate limiting, and stealth headers
+- ✅ **2FA Support** - Two-factor authentication handling
+- ✅ **Message Attachments** - Support for images, videos, files, stickers, and more
+- ✅ **Typing Indicators** - Send and receive typing status
+- ✅ **Read Receipts** - Message read confirmation
+- ✅ **Thread Management** - Create, delete, rename threads
+- ✅ **Mention Support** - Tag users in messages (both legacy and new formats)
+- ✅ **Configurable Options** - Extensive customization options
+
+## 📦 Installation
+
+```bash
+npm install shadowx-fca
+```
+
+Requirements
+
+· Node.js >= 16.0.0
+· npm >= 7.0.0
+
+🚀 Quick Start
+
+Method 1: Using AppState (Recommended)
+
+```javascript
+const login = require('shadowx-fca');
+const fs = require('fs');
+
+// Load saved appState
+const appState = JSON.parse(fs.readFileSync('appstate.json', 'utf8'));
+
+login({ appState: appState }, (err, api) => {
+    if (err) return console.error('Login failed:', err);
+    
+    console.log('✅ Logged in successfully!');
+    
+    // Listen for incoming messages
+    api.listenMqtt((err, message) => {
+        if (err) return console.error('Listen error:', err);
+        
+        if (message.type === 'message') {
+            console.log(`[${message.senderID}] ${message.body}`);
+            
+            // Reply to message
+            api.sendMessage('Hello! I\'m a bot!', message.threadID);
+        }
+    });
+});
+```
+
+Method 2: Email & Password
+
+```javascript
+const login = require('shadowx-fca');
+
+login({ 
+    email: 'your_email@example.com', 
+    password: 'your_password' 
+}, (err, api) => {
+    if (err) return console.error('Login failed:', err);
+    
+    console.log('✅ Logged in successfully!');
+    
+    // Save appState for future use
+    const appState = api.getAppState();
+    fs.writeFileSync('appstate.json', JSON.stringify(appState, null, 2));
+    
+    // Your bot logic here
+});
+```
+
+🔐 Authentication Methods
+
+1. AppState (Recommended)
+
+Most secure method - uses saved cookies instead of credentials.
+
+Get your appState:
+
+```javascript
+const login = require('shadowx-fca');
+const fs = require('fs');
+
+login({ email: 'your_email', password: 'your_password' }, (err, api) => {
+    if (err) return console.error(err);
+    
+    const appState = api.getAppState();
+    fs.writeFileSync('appstate.json', JSON.stringify(appState, null, 2));
+    console.log('✅ AppState saved! You can now use this file to login.');
+    process.exit(0);
+});
+```
+
+2. Email & Password
+
+Traditional method with 2FA support.
+
+With 2FA:
+
+```javascript
+login({ email: 'email@example.com', password: 'password' }, (err, api) => {
+    if (err && err.error === 'login-approval') {
+        console.log('Enter 2FA code:');
+        // Get code from user input
+        const twoFACode = '123456';
+        err.continue(twoFACode);
+    }
+});
+```
+
+📚 API Documentation
+
+Core Methods
+
+login(loginData, [options], callback)
+
+Main login function.
+
+Parameters:
+
+· loginData - Object containing either appState or email/password
+· options - Optional configuration object
+· callback - Function called after login
+
+api.sendMessage(message, threadID, [callback], [replyToMessage], [isSingleUser])
+
+Send a message to a thread.
+
+```javascript
+// Simple message
+api.sendMessage('Hello world!', 'thread_id_here');
+
+// With reply
+api.sendMessage('Replying to you!', 'thread_id_here', null, 'message_id_here');
+
+// With mention
+api.sendMessage('Hello @John Doe', 'thread_id_here');
+```
+
+api.listenMqtt(callback)
+
+Listen for incoming events (messages, typing, presence).
+
+```javascript
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+    
+    switch(event.type) {
+        case 'message':
+            console.log('New message:', event.body);
+            break;
+        case 'event':
+            console.log('Thread event:', event.logMessageType);
+            break;
+        case 'typ':
+            console.log(event.isTyping ? 'Typing...' : 'Stopped typing');
+            break;
+    }
+});
+```
+
+api.getThreadInfo(threadID, callback)
+
+Get information about a thread.
+
+```javascript
+api.getThreadInfo('thread_id_here', (err, info) => {
+    if (err) return console.error(err);
+    console.log('Thread name:', info.name);
+    console.log('Participants:', info.participants);
+    console.log('Unread count:', info.unreadCount);
+});
+```
+
+api.getUserInfo(userID, callback)
+
+Get user information.
+
+```javascript
+api.getUserInfo('user_id_here', (err, info) => {
+    if (err) return console.error(err);
+    console.log('Name:', info.name);
+    console.log('Gender:', info.gender);
+});
+```
+
+api.setOptions(options)
+
+Update API options at runtime.
+
+```javascript
+api.setOptions({
+    listenEvents: true,
+    autoMarkRead: false,
+    delayBetweenRequests: 2000
+});
+```
+
+Additional Methods
+
+Method Description
+api.getAppState() Get current appState (cookies)
+api.markAsRead(threadID, callback) Mark thread as read
+api.markAsDelivered(threadID, messageID, callback) Mark message as delivered
+api.sendTypingIndicator(threadID, callback) Send typing indicator
+api.changeNickname(nickname, threadID, userID, callback) Change user nickname
+api.addUserToGroup(userID, threadID, callback) Add user to group
+api.removeUserFromGroup(userID, threadID, callback) Remove user from group
+api.createNewGroup(participantIDs, groupName, callback) Create new group
+api.deleteThread(threadID, callback) Delete/leave thread
+api.getThreadList(limit, timestamp, tags, callback) Get thread list
+
+⚙️ Configuration
+
+Global Configuration (config.json)
+
+Create config.json in your project root:
+
+```json
+{
+    "enableTypingIndicator": false,
+    "typingDuration": 4000,
+    "delayBetweenRequests": 1500,
+    "autoMarkDelivery": false,
+    "autoMarkRead": false,
+    "listenEvents": true,
+    "selfListen": false,
+    "autoReconnect": true,
+    "logLevel": "info",
+    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+}
+```
+
+Options Reference
+
+Option Type Default Description
+selfListen Boolean false Listen to own messages
+listenEvents Boolean true Listen to thread events
+listenTyping Boolean false Listen to typing indicators
+updatePresence Boolean false Update online status
+forceLogin Boolean false Force login even if suspicious
+autoMarkDelivery Boolean false Auto-mark messages as delivered
+autoMarkRead Boolean false Auto-mark messages as read
+autoReconnect Boolean true Auto-reconnect on disconnect
+delayBetweenRequests Number 1000 Delay between API requests (ms)
+logLevel String "info" Log level (silent/error/warn/info/verbose)
+
+🛡️ Anti-Detection Features
+
+shadowx-fca includes several features to avoid Facebook's anti-bot detection:
+
+1. Rate Limiting
+
+```javascript
+// Set custom delay between requests
+api.setOptions({ delayBetweenRequests: 2000 });
+```
+
+2. Rotating User Agents
+
+Automatically rotates between different user agents to avoid fingerprinting.
+
+3. Stealth Headers
+
+Includes realistic browser headers (Sec-Ch-Ua, Accept-Language, etc.)
+
+4. Request Queue
+
+Automatically queues and spaces out requests to prevent rate limiting.
+
+🔧 Troubleshooting
+
+Common Issues & Solutions
+
+1. "Error! Your cookiestate is not valid!"
+
+Solution: Refresh your appState
+
+```javascript
+// Get new appState
+login({ email: 'your_email', password: 'your_password' }, (err, api) => {
+    const newAppState = api.getAppState();
+    fs.writeFileSync('appstate.json', JSON.stringify(newAppState, null, 2));
+});
+```
+
+2. Account Suspension
+
+Solutions:
+
+· Increase delay between requests
+· Don't spam messages (add 2-3 second delays)
+· Use appState instead of email/password
+· Avoid running 24/7
+· Use a proxy if running multiple bots
+
+3. Login Timeout
+
+Solution: Increase timeout in options
+
+```javascript
+login({ appState: appState }, { timeout: 120000 }, callback);
+```
+
+4. MQTT Connection Issues
+
+Solution: Enable auto-reconnect
+
+```javascript
+api.setOptions({ autoReconnect: true });
+```
+
+💡 Examples
+
+Simple Echo Bot
+
+```javascript
+const login = require('shadowx-fca');
+
+login({ appState: require('./appstate.json') }, (err, api) => {
+    if (err) return console.error(err);
+    
+    api.listenMqtt((err, message) => {
+        if (err) return console.error(err);
+        
+        if (message.type === 'message' && message.body) {
+            // Echo the message back
+            api.sendMessage(message.body, message.threadID);
+        }
+    });
+});
+```
+
+Command Handler
+
+```javascript
+const commands = {
+    '!help': (api, message) => {
+        api.sendMessage('Available commands: !help, !time, !ping', message.threadID);
+    },
+    '!time': (api, message) => {
+        api.sendMessage(`Current time: ${new Date().toLocaleString()}`, message.threadID);
+    },
+    '!ping': (api, message) => {
+        api.sendMessage('Pong!', message.threadID);
+    }
+};
+
+login({ appState: require('./appstate.json') }, (err, api) => {
+    if (err) return console.error(err);
+    
+    api.listenMqtt((err, message) => {
+        if (err) return console.error(err);
+        
+        if (message.type === 'message' && message.body) {
+            const cmd = message.body.split(' ')[0];
+            if (commands[cmd]) commands[cmd](api, message);
+        }
+    });
+});
+```
+
+Auto-Reply with Delay
+
+```javascript
+login({ appState: require('./appstate.json') }, (err, api) => {
+    if (err) return console.error(err);
+    
+    api.listenMqtt((err, message) => {
+        if (err) return console.error(err);
+        
+        if (message.type === 'message' && !message.isGroup) {
+            // Add delay to avoid rate limiting
+            setTimeout(() => {
+                api.sendMessage('Thanks for your message! I\'ll reply soon.', message.threadID);
+            }, 3000);
+        }
+    });
+});
+```
+
+📝 Changelog
+
+v2.1.0 (Latest)
+
+· ✨ Added rotating user agents for anti-detection
+· 🚀 Implemented request queue with rate limiting
+· 🔧 Fixed email/password login issues
+· 🛡️ Enhanced security headers
+· 📚 Improved documentation
+
+v2.0.0
+
+· Added auto-update system
+· Improved MQTT connection stability
+· Added support for new mention format
+· Fixed 2FA handling
+
+📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+⚠️ Disclaimer
+
+This project is for educational purposes only. Use at your own risk. The authors are not responsible for any consequences that may arise from using this software, including but not limited to account suspension or legal action from Facebook.
+
+🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+📞 Support
+
+· Issues: t.me/mueidmursalinrifat
+· Author: Mueid Mursalin Rifat
+
+---
+
+<div align="center">
+  Made with ❤️ by Mueid Mursalin Rifat
+</div>
+```

package/index.js

@@ -3,28 +3,11 @@
 var utils = require("./utils");
 var cheerio = require("cheerio");
 var log = require("npmlog");
-var { checkForFCAUpdate } = require("./checkUpdate");
-const fs = require('fs');
-const path = require('path');
-/*var { getThemeColors } = require("../../func/utils/log.js");
-var logger = require("../../func/utils/log.js");
-var { cra, cv, cb, co } = getThemeColors();*/
+
 log.maxRecordSize = 100;
 var checkVerified = null;
 const Boolean_Option = ['online', 'selfListen', 'listenEvents', 'updatePresence', 'forceLogin', 'autoMarkDelivery', 'autoMarkRead', 'listenTyping', 'autoReconnect', 'emitReady'];
 global.ditconmemay = false;
-global.stfcaUpdateChecked = false;
-
-// Auto-check for updates on package load (non-blocking)
-if (!global.stfcaUpdateChecked) {
-    global.stfcaUpdateChecked = true;
-    const { checkForFCAUpdate } = require("./checkUpdate");
-    setImmediate(() => {
-        checkForFCAUpdate().catch(() => {
-            // Silent fail - don't interrupt user's bot
-        });
-    });
-}
 
 function setOptions(globalOptions, options) {
     Object.keys(options).map(function (key) {
@@ -190,86 +173,6 @@ function buildAPI(globalOptions, html, jar) {
         reqCallbacks: {},
         threadTypes: {} // Store thread type (dm/group) for each thread
     };
-    let config = { enableTypingIndicator: false, typingDuration: 4000 };
-    try {
-        // Prefer global root config (project-level), but fallback to fca/config.json if present.
-        const rootConfigPath = path.join(process.cwd(), 'config.json');
-        if (fs.existsSync(rootConfigPath)) {
-            const rootConfig = JSON.parse(fs.readFileSync(rootConfigPath, 'utf8'));
-            if (rootConfig && typeof rootConfig === 'object') {
-                if (typeof rootConfig.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = rootConfig.enableTypingIndicator;
-                if (typeof rootConfig.typingDuration !== 'undefined') config.typingDuration = rootConfig.typingDuration;
-            }
-        }
-
-        const fcaConfigPath = path.join(__dirname, 'config.json');
-        if (fs.existsSync(fcaConfigPath)) {
-            const fcaConfig = JSON.parse(fs.readFileSync(fcaConfigPath, 'utf8'));
-            if (fcaConfig && typeof fcaConfig === 'object') {
-                if (typeof fcaConfig.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = fcaConfig.enableTypingIndicator;
-                if (typeof fcaConfig.typingDuration !== 'undefined') config.typingDuration = fcaConfig.typingDuration;
-            }
-        }
-
-        if (global.GoatBot && global.GoatBot.config) {
-            if (typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = global.GoatBot.config.enableTypingIndicator;
-            if (typeof global.GoatBot.config.typingDuration !== 'undefined') config.typingDuration = global.GoatBot.config.typingDuration;
-        }
-    } catch (e) {
-        console.log('Error loading config.json:', e);
-    }
-
-    const refreshFcaConfig = () => {
-        try {
-            // Defaults first
-            const updatedConfig = { enableTypingIndicator: false, typingDuration: 4000 };
-
-            // Layered config sources
-            if (fs.existsSync(path.join(process.cwd(), 'config.json'))) {
-                const rootConfig = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'config.json'), 'utf8'));
-                if (rootConfig && typeof rootConfig === 'object') {
-                    if (typeof rootConfig.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = rootConfig.enableTypingIndicator;
-                    if (typeof rootConfig.typingDuration !== 'undefined') updatedConfig.typingDuration = rootConfig.typingDuration;
-                }
-            }
-
-            if (fs.existsSync(path.join(__dirname, 'config.json'))) {
-                const fcaConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config.json'), 'utf8'));
-                if (fcaConfig && typeof fcaConfig === 'object') {
-                    if (typeof fcaConfig.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = fcaConfig.enableTypingIndicator;
-                    if (typeof fcaConfig.typingDuration !== 'undefined') updatedConfig.typingDuration = fcaConfig.typingDuration;
-                }
-            }
-
-            if (global.GoatBot && global.GoatBot.config) {
-                if (typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = global.GoatBot.config.enableTypingIndicator;
-                if (typeof global.GoatBot.config.typingDuration !== 'undefined') updatedConfig.typingDuration = global.GoatBot.config.typingDuration;
-            }
-
-            ctx.config = updatedConfig;
-            config = updatedConfig;
-            if (global.GoatBot) global.GoatBot.config = global.GoatBot.config || {};
-            if (global.GoatBot && typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') {
-                global.GoatBot.config.enableTypingIndicator = updatedConfig.enableTypingIndicator;
-            }
-            if (global.GoatBot && typeof global.GoatBot.config.typingDuration !== 'undefined') {
-                global.GoatBot.config.typingDuration = updatedConfig.typingDuration;
-            }
-        } catch (e) {
-            console.log('Failed to refresh fca config:', e);
-        }
-    };
-
-    // Initial config load
-    refreshFcaConfig();
-
-    // Accessible runtime API for config reload
-    ctx.refreshFcaConfig = refreshFcaConfig;
-    if (global.GoatBot) {
-        global.GoatBot.refreshFcaConfig = refreshFcaConfig;
-    }
-
-    ctx.config = config;
     var api = {
         setOptions: setOptions.bind(null, globalOptions),
         getAppState: () => utils.getAppState(jar),
@@ -523,14 +426,6 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
 
 
 function login(loginData, options, callback) {
-    // Check for updates (non-blocking, only once per session)
-    if (!global.stfcaUpdateChecked) {
-        global.stfcaUpdateChecked = true;
-        checkForFCAUpdate().catch(err => {
-            // Silently ignore update check errors to not block login
-        });
-    }
-
     if (utils.getType(options) === 'Function' || utils.getType(options) === 'AsyncFunction') {
         callback = options;
         options = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadowx-fca",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Unofficial Facebook Chat API for Node.js with Auto-Update System -  modify by Mueid Mursalin Rifat",
   "main": "index.js",
   "files": [