nexus-fca 2.0.3 → 2.0.5

package/CHANGELOG.md

@@ -1,6 +1,40 @@
-#
 # Changelog
-#
+
+## [2.0.5] - 2025-07-29 - FULLY INTEGRATED NPM EDITION
+### 🎯 MAJOR: Full NPM Integration
+- **✅ FULLY INTEGRATED**: Entire Nexus Login System now embedded directly in main `index.js`
+- **📦 NPM COMPATIBLE**: Works perfectly when installed via `npm install nexus-fca` - no external folder dependencies
+- **⚡ ZERO CONFIG**: Everything works out of the box - no separate folder setup required
+- **🔄 SEAMLESS MIGRATION**: Existing code continues to work, new code benefits from integration
+
+### Added
+- 🎯 **Direct exports**: `nexusLogin` and `IntegratedNexusLoginSystem` available directly from main package
+- 🧪 **Updated test files**: All test scripts now use integrated system (`require('nexus-fca')` instead of `./nexloginsystem`)
+- 📖 **New documentation**: `npm-integration-guide.md` with complete NPM usage guide
+- 🛠️ **NPM scripts**: Added `test:login`, `test:simple`, `test:2fa`, `test:all` for easy testing
+- 📦 **Enhanced package.json**: Updated keywords, description, and version for NPM integration
+
+### Changed
+- 🏗️ **Architecture**: Moved entire Nexus Login System from external folder into main index.js (lines 372-860+)
+- 📝 **Documentation**: Updated README.md to reflect NPM installation and integrated usage
+- 🔧 **Test files**: Fixed all test imports to use main package instead of external folder
+- 📦 **Package info**: Updated to v2.0.5 with new description highlighting NPM integration
+
+### Fixed
+- ❌ **NPM module errors**: Eliminated "Cannot find module './nexloginsystem'" when using as npm package
+- 🔗 **Import paths**: All test files and examples now use correct import paths for npm usage
+- 🎯 **Distribution**: Package now works identically whether used locally or installed via npm
+
+## [2.0.4] - 2025-07-29
+### Fixed
+- 🐛 **Missing nexloginsystem folder**: Added `nexloginsystem/` to npm package files array to fix "Cannot find module './nexloginsystem'" error
+- 🔄 **Legacy login fallback**: Added automatic fallback to appstate-only login when Nexus Login System is not available
+- 🛡️ **Backward compatibility**: Enhanced compatibility for users using nexus-fca as npm dependency without full login system
+
+### Changed
+- Updated package.json to include nexloginsystem folder in published package
+- Enhanced error handling with graceful fallback mechanisms
+
 ## [2.0.1] - 2025-07-28
 ### Added
 - 🚀 **Nexus Login System**: Advanced, safe, and automatic Facebook login system added under `/nexloginsystem`.

package/README.md

@@ -38,28 +38,30 @@ Use responsibly and at your own risk. This package is not affiliated with Facebo
 
 ---
 
-## 🚀 What's New in 2.0.2 - Nexus Login System Edition
-- **🔐 NEXUS LOGIN SYSTEM**: Revolutionary auto-login with appstate generation from username/password
+## 🚀 What's New in 2.0.3 - Fully Integrated NPM Edition
+- **🎯 FULLY INTEGRATED**: Nexus Login System now built directly into main package!
+- **� NPM COMPATIBLE**: Works perfectly when installed via `npm install nexus-fca`
+- **⚡ ZERO CONFIG**: No external folders needed - everything works out of the box
+- **�🔐 NEXUS LOGIN SYSTEM**: Revolutionary auto-login with appstate generation from username/password
 - **🛡️ ULTRA-LOW BAN RATE**: Advanced protection reduces Facebook account suspension risk by 95%+
-- **� SMART AUTO-LOGIN**: Automatically detects existing appstate or generates new one seamlessly
 - **🔐 2FA SUPPORT**: Full TOTP integration with Google Authenticator for maximum security
 - **⚡ ONE-LINE SETUP**: Complete bot setup with just one line of code
 - **📊 INTELLIGENT MANAGEMENT**: Auto-backup, validation, and appstate lifecycle management
 - **🛡️ MAXIMUM SAFETY**: Human-like device simulation with Android fingerprinting
 - **🔄 ENHANCED AUTO-RECONNECT**: Smart MQTT connection with safe reconnection patterns
-- **📊 OPTIMIZED SAFETY**: Intelligent caching and safety-focused database optimization
-- **🛡️ PROACTIVE MONITORING**: Advanced account health monitoring and early warning system
-- **🔐 ADVANCED APPSTATE GENERATOR**: Generate fresh appstate cookies with enhanced Android simulation
-- **🤖 LATEST DEVICE SIMULATION**: Support for Pixel 7, Galaxy S23, OnePlus 11 and latest Android versions
-- **🔒 ENHANCED 2FA SUPPORT**: TOTP generation and multiple authentication methods
 
-## � Nexus Login System - Revolutionary Auto-Login
+## 🎯 Integrated Nexus Login System
 
-**The most advanced Facebook login system for bot development**
+**The most advanced Facebook login system, now fully integrated for NPM usage!**
+
+### � **NPM Installation**
+```bash
+npm install nexus-fca
+```
 
 ### ⚡ **One-Line Bot Setup**
 ```javascript
-const { nexusLogin } = require('./nexloginsystem');
+const { nexusLogin } = require('nexus-fca'); // Works directly from npm!
 
 // Complete bot ready in one line!
 const result = await nexusLogin({
@@ -85,7 +87,7 @@ if (result.success) {
 const result = await nexusLogin(); // No credentials needed if appstate exists!
 ```
 
-### �️ **Maximum Safety Features**
+### 🛡️ **Maximum Safety Features**
 - ✅ **Human-like Android simulation** with real device fingerprints
 - ✅ **2FA TOTP auto-generation** from Google Authenticator secrets
 - ✅ **Rate limiting & safety delays** to prevent Facebook detection
@@ -95,51 +97,59 @@ const result = await nexusLogin(); // No credentials needed if appstate exists!
 
 ### 📚 **Quick Start Guide**
 
-1. **Setup credentials:**
-```bash
-# Edit nexloginsystem/test.js with your Facebook credentials
-nano nexloginsystem/test.js
 ```
 
-2. **Test the system:**
-```bash
-node nexloginsystem/test.js
+2. **Create test file:**
+```javascript
+// test-bot.js
+const { nexusLogin } = require('nexus-fca');
+
+(async () => {
+    const result = await nexusLogin({
+        username: 'your_email@gmail.com',
+        password: 'your_password'
+    });
+    
+    if (result.success) {
+        console.log('✅ Bot ready!');
+        result.api.sendMessage('Hello from Nexus!', result.api.getCurrentUserID());
+    }
+})();
 ```
 
-3. **Use in your project:**
-```javascript
-const { nexusLogin } = require('./nexloginsystem');
-const result = await nexusLogin(credentials);
+3. **Run your bot:**
+```bash
+node test-bot.js
 ```
 
-### � **Full Documentation**
-- **[Nexus Login System Guide](nexloginsystem/README.md)** - Complete documentation
-- **[Examples & Usage Patterns](nexloginsystem/examples.js)** - Real-world examples
-- **[API Reference](nexloginsystem/README.md#api-reference)** - Detailed API docs
+### 📖 **Complete Documentation**
+- **[NPM Integration Guide](npm-integration-guide.md)** - Complete NPM usage guide
+- **[Integrated Login Guide](integrated-login-guide.md)** - All login methods
+- **[Test Files](test-*.js)** - Ready-to-use test scripts
+- **[Legacy Guide](newloginhowtouse.md)** - Previous version docs
 
 ---
 
-## 🔐 Advanced Appstate Generator (Legacy)
+## 🔐 Legacy Appstate Support
 
-Nexus-FCA includes a sophisticated appstate generator for manual setup scenarios.
+Nexus-FCA maintains full backward compatibility with traditional appstate login.
 
-### ⚡ Quick Setup
+### ⚡ Traditional Usage
 
-1. **Install dependencies:**
-```bash
-npm install
-```
+```javascript
+const login = require('nexus-fca');
 
-2. **Test with Nexus-FCA:**
-```bash
-npm run test:safety
+login({ appState: require('./appstate.json') }, (err, api) => {
+    if (err) return console.error(err);
+    console.log('✅ Bot ready with appstate!');
+});
 ```
 
-### 📚 Documentation
+### 📚 Migration Guide
 
-- **[Security Best Practices](docs/account-safety.md)** - Account protection guidelines
-- **💪 INTELLIGENT ERROR RECOVERY**: Smart error handling that avoids triggering Facebook security
-- **📈 SAFETY ANALYTICS**: Real-time monitoring focused on account protection
+- **Existing appstate files work unchanged**
+- **New integrated system generates fresh appstate automatically**
+- **Mix and match both approaches as needed**
 
 ---
 

package/index.js

@@ -256,11 +256,645 @@ function buildAPI(globalOptions, html, jar) {
   };
 }
 
-// --- REPLACE LEGACY LOGIN WITH NEXUS LOGIN SYSTEM ---
-const { nexusLogin } = require('./nexloginsystem');
+// Legacy login helper function for appstate-only login
+function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
+  let mainPromise = null;
+  const jar = utils.getJar();
+  
+  // Apply maximum safety validation
+  const safetyCheck = globalSafety.validateLogin(appState, email, password);
+  if (!safetyCheck.safe) {
+    return callback(new Error(`Login Safety Check Failed: ${safetyCheck.reason}`));
+  }
+  
+  // Apply safe user agent from safety module
+  globalOptions.userAgent = globalSafety.getSafeUserAgent();
+  
+  if (appState) {
+    try {
+      appState = JSON.parse(appState);
+    } catch (e) {
+      try {
+        appState = appState;
+      } catch (e) {
+        return callback(new Error("Failed to parse appState"));
+      }
+    }
+
+    try {
+      appState.forEach(c => {
+        const str = `${c.key}=${c.value}; expires=${c.expires}; domain=${c.domain}; path=${c.path};`;
+        jar.setCookie(str, "http://" + c.domain);
+      });
+
+      // Apply safety headers and no delays for maximum safety
+      mainPromise = utils.get('https://www.facebook.com/', jar, null, 
+        globalSafety.applySafeRequestOptions(globalOptions), { noRef: true })
+        .then(utils.saveCookies(jar));
+    } catch (e) {
+      return callback(new Error("Invalid appState format"));
+    }
+  } else {
+    return callback(new Error("AppState is required for legacy login"));
+  }
+
+  function handleRedirect(res) {
+    const reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+    const redirect = reg.exec(res.body);
+    if (redirect && redirect[1]) {
+      return utils.get(redirect[1], jar, null, globalOptions).then(utils.saveCookies(jar));
+    }
+    return res;
+  }
+
+  let ctx, api;
+  mainPromise = mainPromise
+    .then(handleRedirect)
+    .then(res => {
+      const mobileAgentRegex = /MPageLoadClientMetrics/gs;
+      if (!mobileAgentRegex.test(res.body)) {
+        globalOptions.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36";
+        return utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true }).then(utils.saveCookies(jar));
+      }
+      return res;
+    })
+    .then(handleRedirect)
+    .then(res => {
+      const html = res.body;
+      const Obj = buildAPI(globalOptions, html, jar);
+      ctx = Obj.ctx;
+      api = Obj.api;
+      return res;
+    });
+
+  if (globalOptions.pageID) {
+    mainPromise = mainPromise
+      .then(() => utils.get(`https://www.facebook.com/${globalOptions.pageID}/messages/?section=messages&subsection=inbox`, jar, null, globalOptions))
+      .then(resData => {
+        let url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
+        url = url.substring(0, url.length - 1);
+        return utils.get('https://www.facebook.com' + url, jar, null, globalOptions);
+      });
+  }
+
+  mainPromise
+    .then(async () => {
+      // Enhanced safety check after login
+      const safetyStatus = globalSafety.validateSession(ctx);
+      if (!safetyStatus.safe) {
+        logger(`⚠️ Login safety warning: ${safetyStatus.reason}`, 'warn');
+      }
+      
+      logger('Legacy login successful!', 'info');
+      
+      // Initialize safety monitoring
+      globalSafety.startMonitoring(ctx, api);
+      
+      callback(null, api);
+    })
+    .catch(e => {
+      // Enhanced error handling with safety checks
+      const safetyCheck = globalSafety.checkErrorSafety(e);
+      if (!safetyCheck.safe) {
+        logger(`🚨 SAFETY ALERT: ${safetyCheck.danger} - ${e.message}`, 'error');
+      }
+      
+      callback(e);
+    });
+}
+
+// --- INTEGRATED NEXUS LOGIN SYSTEM ---
+// Full Nexus Login System integrated for npm package compatibility
+const { v4: uuidv4 } = require('uuid');
+const { TOTP } = require("totp-generator");
+const crypto = require('crypto');
+
+class IntegratedNexusLoginSystem {
+    constructor(options = {}) {
+        this.options = {
+            appstatePath: options.appstatePath || path.join(process.cwd(), 'appstate.json'),
+            credentialsPath: options.credentialsPath || path.join(process.cwd(), 'credentials.json'),
+            backupPath: options.backupPath || path.join(process.cwd(), 'backups'),
+            autoLogin: options.autoLogin !== false,
+            autoSave: options.autoSave !== false,
+            safeMode: options.safeMode !== false,
+            maxRetries: options.maxRetries || 3,
+            retryDelay: options.retryDelay || 5000,
+            ...options
+        };
+
+        this.deviceCache = new Map();
+        this.loginAttempts = 0;
+        this.lastLoginTime = 0;
+        
+        this.ensureDirectories();
+        this.logger('Nexus Login System initialized', '🚀');
+    }
+
+    logger(message, emoji = '📝') {
+        const timestamp = new Date().toLocaleString();
+        console.log(`${emoji} [${timestamp}] ${message}`);
+    }
+
+    ensureDirectories() {
+        const dirs = [
+            path.dirname(this.options.appstatePath),
+            path.dirname(this.options.credentialsPath),
+            this.options.backupPath
+        ];
+        
+        dirs.forEach(dir => {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        });
+    }
+
+    getRandomDevice() {
+        const devices = [
+            { model: "Pixel 6", build: "SP2A.220505.002", sdk: "30", release: "11" },
+            { model: "Pixel 5", build: "RQ3A.210805.001.A1", sdk: "30", release: "11" },
+            { model: "Samsung Galaxy S21", build: "G991USQU4AUDA", sdk: "30", release: "11" },
+            { model: "OnePlus 9", build: "LE2115_11_C.48", sdk: "30", release: "11" },
+            { model: "Xiaomi Mi 11", build: "RKQ1.200826.002", sdk: "30", release: "11" },
+            { model: "Pixel 7", build: "TD1A.220804.031", sdk: "33", release: "13" },
+            { model: "Samsung Galaxy S22", build: "S901USQU2AVB3", sdk: "32", release: "12" }
+        ];
+        
+        const device = devices[Math.floor(Math.random() * devices.length)];
+        const deviceId = this.generateConsistentDeviceId(device);
+        
+        return {
+            userAgent: `Dalvik/2.1.0 (Linux; U; Android ${device.release}; ${device.model} Build/${device.build})`,
+            device,
+            deviceId,
+            familyDeviceId: uuidv4(),
+            androidId: this.generateAndroidId()
+        };
+    }
+
+    generateConsistentDeviceId(device) {
+        const key = `${device.model}_${device.build}`;
+        if (this.deviceCache.has(key)) {
+            return this.deviceCache.get(key);
+        }
+        
+        const deviceId = uuidv4();
+        this.deviceCache.set(key, deviceId);
+        return deviceId;
+    }
+
+    generateAndroidId() {
+        return crypto.randomBytes(8).toString('hex');
+    }
+
+    randomString(length = 10) {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        let result = 'abcdefghijklmnopqrstuvwxyz'.charAt(Math.floor(Math.random() * 26));
+        for (let i = 0; i < length - 1; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+
+    sort(obj) {
+        return Object.keys(obj).sort().reduce((result, key) => {
+            result[key] = obj[key];
+            return result;
+        }, {});
+    }
+
+    encodesig(data) {
+        const signature = '62f8ce9f74b12f84c123cc23437a4a32';
+        return crypto.createHash('md5').update(Object.keys(data).map(key => `${key}=${data[key]}`).join('&') + signature).digest('hex');
+    }
+
+    async safeDelay(min = 1000, max = 3000) {
+        const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+        return new Promise(resolve => setTimeout(resolve, delay));
+    }
+
+    hasValidAppstate() {
+        try {
+            if (!fs.existsSync(this.options.appstatePath)) return false;
+            const appstate = JSON.parse(fs.readFileSync(this.options.appstatePath, 'utf8'));
+            return Array.isArray(appstate) && appstate.length > 0;
+        } catch (error) {
+            this.logger(`Appstate validation failed: ${error.message}`, '❌');
+            return false;
+        }
+    }
+
+    loadAppstate() {
+        try {
+            const appstate = JSON.parse(fs.readFileSync(this.options.appstatePath, 'utf8'));
+            this.logger(`Loaded appstate with ${appstate.length} cookies`, '✅');
+            return appstate;
+        } catch (error) {
+            this.logger(`Failed to load appstate: ${error.message}`, '❌');
+            return null;
+        }
+    }
+
+    saveAppstate(appstate, metadata = {}) {
+        try {
+            fs.writeFileSync(this.options.appstatePath, JSON.stringify(appstate, null, 2));
+            
+            // Create backup
+            const backupName = `appstate_${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+            const backupPath = path.join(this.options.backupPath, backupName);
+            
+            const backupData = {
+                appstate,
+                metadata: {
+                    ...metadata,
+                    created: new Date().toISOString(),
+                    source: 'NexusLoginSystem'
+                }
+            };
+            
+            fs.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
+            this.logger('Appstate saved and backed up successfully', '💾');
+            
+        } catch (error) {
+            this.logger(`Failed to save appstate: ${error.message}`, '❌');
+        }
+    }
+
+    async generateAppstate(credentials) {
+        try {
+            if (this.options.safeMode) {
+                const timeSinceLastLogin = Date.now() - this.lastLoginTime;
+                if (timeSinceLastLogin < 30000) {
+                    this.logger('Rate limiting: Please wait before next login attempt', '⚠️');
+                    await new Promise(resolve => setTimeout(resolve, 30000 - timeSinceLastLogin));
+                }
+            }
+
+            this.lastLoginTime = Date.now();
+            this.loginAttempts++;
+
+            const androidDevice = this.getRandomDevice();
+            const machineId = this.randomString(24);
+
+            await this.safeDelay(1000, 2000);
+
+            // Clean 2FA secret (remove spaces)
+            if (credentials.twofactor) {
+                credentials.twofactor = credentials.twofactor.replace(/\s+/g, '');
+            }
+
+            const form = {
+                adid: uuidv4(),
+                email: credentials.username,
+                password: credentials.password,
+                format: 'json',
+                device_id: androidDevice.deviceId,
+                cpl: 'true',
+                family_device_id: androidDevice.familyDeviceId,
+                locale: 'en_US',
+                client_country_code: 'US',
+                credentials_type: 'device_based_login_password',
+                generate_session_cookies: '1',
+                generate_analytics_claim: '1',
+                generate_machine_id: '1',
+                currently_logged_in_userid: '0',
+                irisSeqID: 1,
+                try_num: "1",
+                enroll_misauth: "false",
+                meta_inf_fbmeta: "NO_FILE",
+                source: 'login',
+                machine_id: machineId,
+                fb_api_req_friendly_name: 'authenticate',
+                fb_api_caller_class: 'com.facebook.account.login.protocol.Fb4aAuthHandler',
+                api_key: '882a8490361da98702bf97a021ddc14d',
+                access_token: '350685531728|62f8ce9f74b12f84c123cc23437a4a32',
+                advertiser_id: uuidv4(),
+                device_platform: 'android',
+                app_version: '392.0.0.0.66',
+                network_type: 'WIFI'
+            };
+
+            form.sig = this.encodesig(this.sort(form));
+
+            const options = {
+                url: 'https://b-graph.facebook.com/auth/login',
+                method: 'post',
+                data: form,
+                transformRequest: [(data) => require('querystring').stringify(data)],
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded',
+                    'x-fb-friendly-name': form["fb_api_req_friendly_name"],
+                    'x-fb-http-engine': 'Liger',
+                    'user-agent': androidDevice.userAgent,
+                    'x-fb-client-ip': 'True',
+                    'x-fb-server-cluster': 'True',
+                    'x-fb-connection-bandwidth': Math.floor(Math.random() * 40000000) + 10000000,
+                    'x-fb-connection-quality': 'EXCELLENT',
+                    'x-fb-connection-type': 'WIFI',
+                    'x-fb-net-hni': '',
+                    'x-fb-sim-hni': '',
+                    'x-fb-device-group': '5120',
+                    'x-tigon-is-retry': 'False',
+                    'x-fb-rmd': 'cached=0;state=NO_MATCH',
+                    'x-fb-request-analytics-tags': 'unknown',
+                    'authorization': `OAuth ${form.access_token}`,
+                    'accept-language': 'en-US,en;q=0.9',
+                    'x-fb-client-ip': 'True',
+                    'x-fb-server-cluster': 'True'
+                },
+                timeout: 30000
+            };
+
+            this.logger('Attempting login with enhanced security...', '🔐');
+
+            return new Promise((resolve) => {
+                axios.request(options).then(async (response) => {
+                    try {
+                        if (response.data.session_cookies) {
+                            const appstate = response.data.session_cookies.map(cookie => ({
+                                key: cookie.name,
+                                value: cookie.value,
+                                domain: cookie.domain,
+                                path: cookie.path,
+                                expires: cookie.expires,
+                                httpOnly: cookie.httpOnly,
+                                secure: cookie.secure
+                            }));
+
+                            if (credentials.i_user) {
+                                appstate.push({
+                                    key: 'i_user',
+                                    value: credentials.i_user,
+                                    domain: '.facebook.com',
+                                    path: '/'
+                                });
+                            }
+
+                            await this.safeDelay(500, 1500);
+
+                            const result = {
+                                success: true,
+                                appstate: appstate,
+                                access_token: response.data.access_token,
+                                device_info: {
+                                    model: androidDevice.device.model,
+                                    user_agent: androidDevice.userAgent,
+                                    device_id: androidDevice.deviceId
+                                },
+                                generated_at: new Date().toISOString()
+                            };
+
+                            this.saveAppstate(appstate, result);
+                            this.logger('Login successful! Appstate generated and saved', '🎉');
+                            
+                            resolve(result);
+                        }
+                    } catch (e) {
+                        this.logger(`Login processing error: ${e.message}`, '❌');
+                        resolve({
+                            success: false,
+                            message: "Login processing failed. Please try again."
+                        });
+                    }
+                }).catch(async (error) => {
+                    // Handle 2FA requirement
+                    try {
+                        const errorData = error.response?.data?.error?.error_data;
+                        
+                        if (!errorData) {
+                            throw new Error('Unknown login error');
+                        }
+
+                        let twoFactorCode;
+
+                        if (credentials._2fa && credentials._2fa !== "0") {
+                            twoFactorCode = credentials._2fa;
+                        } else if (credentials.twofactor && credentials.twofactor !== "0") {
+                            try {
+                                this.logger('Processing 2FA with TOTP...', '🔐');
+                                const cleanSecret = decodeURI(credentials.twofactor).replace(/\s+/g, '').toUpperCase();
+                                const { otp } = TOTP.generate(cleanSecret);
+                                twoFactorCode = otp;
+                                this.logger(`Generated 2FA code: ${otp}`, '🔑');
+                            } catch (e) {
+                                return resolve({
+                                    success: false,
+                                    message: 'Invalid 2FA secret key format'
+                                });
+                            }
+                        } else {
+                            return resolve({
+                                success: false,
+                                message: 'Two-factor authentication required. Please provide 2FA secret or code.'
+                            });
+                        }
+
+                        await this.safeDelay(2000, 4000);
+
+                        const twoFactorForm = {
+                            ...form,
+                            twofactor_code: twoFactorCode,
+                            encrypted_msisdn: "",
+                            userid: errorData.uid,
+                            machine_id: errorData.machine_id || machineId,
+                            first_factor: errorData.login_first_factor,
+                            credentials_type: "two_factor"
+                        };
+
+                        twoFactorForm.sig = this.encodesig(this.sort(twoFactorForm));
+                        options.data = twoFactorForm;
+
+                        this.logger('Attempting 2FA login...', '🔐');
+
+                        try {
+                            const twoFactorResponse = await axios.request(options);
+
+                            const appstate = twoFactorResponse.data.session_cookies.map(cookie => ({
+                                key: cookie.name,
+                                value: cookie.value,
+                                domain: cookie.domain,
+                                path: cookie.path,
+                                expires: cookie.expires,
+                                httpOnly: cookie.httpOnly,
+                                secure: cookie.secure
+                            }));
+
+                            if (credentials.i_user) {
+                                appstate.push({
+                                    key: 'i_user',
+                                    value: credentials.i_user,
+                                    domain: '.facebook.com',
+                                    path: '/'
+                                });
+                            }
+
+                            const result = {
+                                success: true,
+                                appstate: appstate,
+                                access_token: twoFactorResponse.data.access_token,
+                                device_info: {
+                                    model: androidDevice.device.model,
+                                    user_agent: androidDevice.userAgent
+                                },
+                                method: '2FA',
+                                generated_at: new Date().toISOString()
+                            };
+
+                            this.saveAppstate(appstate, result);
+                            this.logger('2FA login successful! Appstate saved', '🎉');
+                            
+                            resolve(result);
+
+                        } catch (requestError) {
+                            this.logger(`2FA request failed: ${requestError.message}`, '❌');
+                            resolve({
+                                success: false,
+                                message: '2FA verification failed. Check your code and try again.'
+                            });
+                        }
+
+                    } catch (twoFactorError) {
+                        this.logger(`2FA error: ${twoFactorError.message}`, '❌');
+                        resolve({
+                            success: false,
+                            message: 'Login failed. Check credentials and try again.'
+                        });
+                    }
+                });
+            });
+
+        } catch (e) {
+            this.logger(`Unexpected error: ${e.message}`, '💥');
+            return {
+                success: false,
+                message: 'Unexpected error occurred. Please try again.'
+            };
+        }
+    }
+
+    async login(credentials = null) {
+        try {
+            this.logger('Starting Nexus Login System...', '🚀');
+
+            // Check for existing valid appstate first
+            if (this.options.autoLogin && this.hasValidAppstate()) {
+                this.logger('Valid appstate found, loading...', '✅');
+                const appstate = this.loadAppstate();
+                
+                if (appstate) {
+                    return {
+                        success: true,
+                        appstate: appstate,
+                        method: 'existing_appstate',
+                        message: 'Login successful using existing appstate'
+                    };
+                }
+            }
+
+            // No valid appstate, need credentials
+            if (!credentials) {
+                // Try to load from credentials file
+                if (fs.existsSync(this.options.credentialsPath)) {
+                    try {
+                        credentials = JSON.parse(fs.readFileSync(this.options.credentialsPath, 'utf8'));
+                        this.logger('Credentials loaded from file', '📁');
+                    } catch (error) {
+                        this.logger('Failed to load credentials file', '❌');
+                    }
+                }
+
+                if (!credentials) {
+                    return {
+                        success: false,
+                        message: 'No valid appstate found and no credentials provided'
+                    };
+                }
+            }
+
+            // Validate credentials
+            if (!credentials.username || !credentials.password) {
+                return {
+                    success: false,
+                    message: 'Username and password are required'
+                };
+            }
+
+            this.logger('Generating new appstate...', '🔄');
+            
+            // Generate new appstate
+            const result = await this.generateAppstate(credentials);
+            
+            if (result.success) {
+                // Save credentials for future use (optional)
+                if (this.options.autoSave && !fs.existsSync(this.options.credentialsPath)) {
+                    try {
+                        const credentialsToSave = { ...credentials };
+                        delete credentialsToSave.password; // Don't save password for security
+                        fs.writeFileSync(this.options.credentialsPath, JSON.stringify(credentialsToSave, null, 2));
+                    } catch (error) {
+                        this.logger('Failed to save credentials (non-critical)', '⚠️');
+                    }
+                }
+            }
+
+            return result;
+
+        } catch (error) {
+            this.logger(`Login system error: ${error.message}`, '💥');
+            return {
+                success: false,
+                message: `System error: ${error.message}`
+            };
+        }
+    }
+}
+
+// Integrated Nexus Login wrapper for easy usage
+async function integratedNexusLogin(credentials = null, options = {}) {
+    const loginSystem = new IntegratedNexusLoginSystem(options);
+    const result = await loginSystem.login(credentials);
+    
+    if (result.success && options.autoStartBot !== false) {
+        // Auto-start Nexus-FCA with the generated appstate
+        try {
+            return new Promise((resolve) => {
+                login({ appState: result.appstate }, options, (err, api) => {
+                    if (err) {
+                        resolve({
+                            success: true,
+                            appstate: result.appstate,
+                            method: result.method,
+                            warning: 'Appstate ready but bot startup failed',
+                            botError: err.message
+                        });
+                    } else {
+                        resolve({
+                            success: true,
+                            api: api,
+                            appstate: result.appstate,
+                            method: result.method,
+                            message: 'Nexus-FCA bot started successfully'
+                        });
+                    }
+                });
+            });
+        } catch (error) {
+            return {
+                success: true,
+                appstate: result.appstate,
+                method: result.method,
+                warning: 'Appstate ready but bot startup failed',
+                botError: error.message
+            };
+        }
+    }
+    
+    return result;
+}
 
 /**
- * Modern login entry point using Nexus Login System
+ * Modern login entry point using Integrated Nexus Login System
  * Supports: username/password/2FA, auto appstate, ultra-safe mode
  * Usage: login({ email, password, twofactor }, options, callback)
  */
@@ -270,40 +904,83 @@ async function login(loginData, options = {}, callback) {
     callback = options;
     options = {};
   }
-  // Use Nexus Login System for all logins
-  try {
-    const result = await nexusLogin({
-      username: loginData.email || loginData.username,
-      password: loginData.password,
-      twofactor: loginData.twofactor || loginData.otp || undefined,
-      appstate: loginData.appState || loginData.appstate || undefined
-    }, options);
-    if (result.success && result.api) {
-      if (callback) return callback(null, result.api);
-      return result.api;
-    } else {
-      if (callback) return callback(new Error(result.message || 'Login failed'));
-      throw new Error(result.message || 'Login failed');
+  
+  // Use Integrated Nexus Login System for ID/pass login, or legacy for appstate-only
+  if (loginData.email || loginData.username || loginData.password) {
+    try {
+      const result = await integratedNexusLogin({
+        username: loginData.email || loginData.username,
+        password: loginData.password,
+        twofactor: loginData.twofactor || loginData.otp || undefined,
+        _2fa: loginData._2fa || undefined,
+        appstate: loginData.appState || loginData.appstate || undefined
+      }, options);
+      
+      if (result.success && result.api) {
+        if (callback) return callback(null, result.api);
+        return result.api;
+      } else {
+        if (callback) return callback(new Error(result.message || 'Login failed'));
+        throw new Error(result.message || 'Login failed');
+      }
+    } catch (error) {
+      log.error('login', "Nexus Login System error: " + error.message);
+      if (callback) return callback(error);
+      throw error;
+    }
+  } else {
+    // Legacy appstate-only login
+    if (!loginData.appState && !loginData.appstate) {
+      const error = new Error('Username and password are required for login, or provide appState for legacy login.');
+      if (callback) return callback(error);
+      throw error;
     }
-  } catch (error) {
-    log.error('login', "Lỗi không xác định, vui lòng thử lại sau: " + error.message);
-    if (callback) return callback(error);
+    
+    // Legacy appstate login
+    const globalOptions = {
+      selfListen: false,
+      selfListenEvent: false,
+      listenEvents: false,
+      listenTyping: false,
+      updatePresence: false,
+      forceLogin: false,
+      autoMarkDelivery: true,
+      autoMarkRead: false,
+      autoReconnect: true,
+      logRecordSize: defaultLogRecordSize,
+      online: true,
+      emitReady: false,
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+      ...options
+    };
+    
+    return loginHelper(
+      loginData.appState || loginData.appstate,
+      null, // No email for appstate login
+      null, // No password for appstate login
+      globalOptions,
+      callback,
+      null
+    );
   }
 }
 
-module.exports = {
-  buildAPI,
-  login,
-  setOptions,
-  utils,
-  logger,
-  FacebookSafety,
-  CompatibilityLayer,
-  PerformanceManager,
-  ErrorHandler,
-  AdvancedMqttManager,
-  EnhancedDatabase,
-  Message,
-  Thread,
-  User
-};
+// Enhanced exports
+module.exports = login;
+module.exports.buildAPI = buildAPI;
+module.exports.login = login;
+module.exports.nexusLogin = integratedNexusLogin; // Direct access to integrated login system
+module.exports.IntegratedNexusLoginSystem = IntegratedNexusLoginSystem; // Class access
+module.exports.setOptions = setOptions;
+module.exports.utils = utils;
+module.exports.logger = logger;
+module.exports.FacebookSafety = FacebookSafety;
+module.exports.NexusClient = NexusClient;
+module.exports.PerformanceManager = PerformanceManager;
+module.exports.ErrorHandler = ErrorHandler;
+module.exports.AdvancedMqttManager = AdvancedMqttManager;
+module.exports.EnhancedDatabase = EnhancedDatabase;
+module.exports.CompatibilityLayer = CompatibilityLayer;
+module.exports.Message = Message;
+module.exports.Thread = Thread;
+module.exports.User = User;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nexus-fca",
-  "version": "2.0.3",
-  "description": "A modern, safe, and advanced Facebook Chat API for Node.js with enhanced performance, smart caching, and TypeScript support. Messenger automation, bots, and integrations made easy.",
+  "version": "2.0.5",
+  "description": "A modern, safe, and advanced Facebook Chat API for Node.js with fully integrated Nexus Login System. NPM-ready with ID/password/2FA support, ultra-low ban rate protection, and zero external dependencies.",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -51,9 +51,11 @@
     "build:types": "tsc --declaration --emitDeclarationOnly --outDir ./types",
     "performance:test": "node examples/performance-test.js",
     "db:vacuum": "node scripts/vacuum-database.js",
-    "appstate:generate": "node generate-appstate.js",
-    "appstate:clean": "rm -f appstate*.json credentials.json || del appstate*.json credentials.json 2>nul",
-    "setup": "npm install && echo Please create credentials.json with your Facebook login info"
+    "test:login": "node test-nexus-login.js",
+    "test:simple": "node test-login-simple.js",
+    "test:2fa": "node test-id-pass-2fa.js",
+    "test:all": "npm run test:simple && npm run test:2fa && npm run test:login",
+    "setup": "npm install && echo Please configure credentials in test files or use environment variables"
   },
   "keywords": [
     "facebook",
@@ -63,6 +65,11 @@
     "messenger",
     "bot",
     "automation",
+    "login",
+    "2fa",
+    "appstate",
+    "integrated",
+    "npm",
     "typescript",
     "performance",
     "caching",
@@ -124,6 +131,7 @@
     "utils.js",
     "src/",
     "lib/",
+    "nexloginsystem/",
     "docs/",
     "ENHANCED_DOCS.md",
     "README.md",