messenger-web-reverse

messenger-web-reverse - Real Facebook Messenger Client for Node.js

A comprehensive Node.js library that provides real Facebook Messenger functionality similar to Baileys for WhatsApp. This library connects directly to Facebook's servers using reverse-engineered protocols, enabling authentic messaging without browser automation.

🚀 Features

• Real Facebook Connection: Direct WebSocket connection to Facebook's servers
• No Browser Automation: Pure HTTP/WebSocket implementation, no Puppeteer required
• Email/Password Authentication: Login with your Facebook credentials
• Session Management: Persistent sessions with automatic restoration
• Real-time Messaging: Send and receive messages instantly
• Event-driven Architecture: Clean, reactive programming model
• Auto-reconnection: Automatic reconnection with configurable retry logic
• Typing Indicators: Send and receive typing status
• Message History: Retrieve conversation history
• Cross-platform: Works on Windows, Linux, macOS, Android (Termux)

📦 Installation

Install the library using npm:

npm install messenger-web-reverse

Or using yarn:

yarn add messenger-web-reverse

Or using pnpm:

pnpm add messenger-web-reverse

🌍 NPM Package

Package Name: messenger-web-reverse
Current Version: 2.2.0
NPM Link: https://www.npmjs.com/package/messenger-web-reverse

# Install the latest version
npm install messenger-web-reverse@latest

🎯 Quick Start

const FacebookMessenger = require('messenger-web-reverse');

async function main() {
    const messenger = new FacebookMessenger({
        debug: true
    });
    
    // Setup event handlers
    messenger.on('message', (message) => {
        console.log(`📩 New message from ${message.from}: ${message.body}`);
    });
    
    messenger.on('connected', () => {
        console.log('🌐 Connected to Facebook Messenger!');
    });
    
    // Login with Facebook credentials - METODA CORECTĂ
    const loginResult = await messenger.login('[e-mail]', 'your-password');
    
    if (loginResult.success) {
        // Connect to WebSocket
        await messenger.connect();
        
        // Send a message
        await messenger.sendMessage('recipient-user-id', 'Hello from FacebookMessenger!');
    }
}

main().catch(console.error);

🔐 Authentication - METODĂ CORECTĂ

⚠️ IMPORTANT: Metoda corectă de autentificare este messenger.login(), NU client.login() sau messenger.authenticate()!

Biblioteca suportă autentificare reală Facebook cu persistența sesiunii:

const messenger = new FacebookMessenger();

// METODA CORECTĂ: folosește messenger.login() nu client.login()!
const loginResult = await messenger.login('[e-mail]', 'password');

if (loginResult.success) {
    console.log('✅ Login successful');
    console.log('👤 User:', loginResult.user.userInfo.name);
    console.log('🆔 User ID:', loginResult.user.userId);
    
    await messenger.connect();
} else if (loginResult.requires2FA) {
    console.log('🔒 Two-factor authentication required');
} else {
    console.log('❌ Login failed:', loginResult.error);
}

// Subsequent runs - automatic session restoration  
if (await messenger.restoreSession()) {
    console.log('📂 Session restored successfully');
    await messenger.connect();
} else {
    // Need to login again - FOLOSEȘTE MEREU messenger.login()
    await messenger.login('[e-mail]', 'password');
}

📱 Real-time Events

The library emits real-time events from Facebook's servers:

// Message events
messenger.on('message', (message) => {
    console.log(`📩 Message from ${message.from}: ${message.body}`);
    console.log(`🕐 Timestamp: ${new Date(message.timestamp)}`);
    console.log(`💬 Thread ID: ${message.threadId}`);
});

messenger.on('message_sent', (data) => {
    console.log(`📤 Message sent successfully: ${data.messageId}`);
});

// Delivery and read receipts
messenger.on('delivery_receipt', (receipt) => {
    console.log(`✅ Message delivered: ${receipt.messageId}`);
});

messenger.on('read_receipt', (receipt) => {
    console.log(`👁️ Message read: ${receipt.messageId}`);
});

// Typing indicators
messenger.on('typing', (typing) => {
    console.log(`⌨️ ${typing.from} is ${typing.isTyping ? 'typing' : 'stopped typing'}...`);
});

// Presence updates
messenger.on('presence', (presence) => {
    console.log(`👤 ${presence.userId} is ${presence.status}`);
});

// Connection events
messenger.on('connected', () => console.log('🌐 Connected to Facebook'));
messenger.on('disconnected', (data) => console.log('📴 Disconnected:', data));
messenger.on('error', (error) => console.error('❌ Error:', error.message));

💬 Sending Messages

Text Messages

// Send simple text message
await messenger.sendMessage('user-id', 'Hello, World!');

// Send message with options
await messenger.sendMessage('user-id', 'Hello!', {
    source: 'chat:web'
});

Typing Indicators

// Show typing indicator
await messenger.sendTypingIndicator('user-id', true);

// Simulate typing and send message
await messenger.sendTypingIndicator('user-id', true);
setTimeout(async () => {
    await messenger.sendTypingIndicator('user-id', false);
    await messenger.sendMessage('user-id', 'Hello after typing!');
}, 2000);

📚 Message History

// Get recent messages from a conversation
const messages = await messenger.getMessages('user-id', 20);

console.log(`📜 Retrieved ${messages.length} messages:`);
messages.forEach((msg, index) => {
    console.log(`${index + 1}. ${msg.body} (from: ${msg.from})`);
});

⚙️ Configuration Options

const messenger = new FacebookMessenger({
    debug: true,                           // Enable debug logging
    sessionPath: './facebook_session.json', // Session storage path
    autoReconnect: true,                   // Auto-reconnect on disconnect
    maxReconnectAttempts: 5,               // Max reconnection attempts
    reconnectDelay: 5000,                  // Delay between reconnects (ms)
    userAgent: 'Custom User Agent'         // Custom user agent string
});

🔄 Session Management

Sessions are automatically managed and persisted:

// Sessions are saved automatically after successful login
await messenger.login('email', 'password');

// Check session status
const status = messenger.getStatus();
console.log('📊 Status:', {
    isConnected: status.isConnected,
    isLoggedIn: status.isLoggedIn,
    userId: status.userId
});

// Manual logout (clears session)
await messenger.logout();

🛠️ Error Handling

try {
    const loginResult = await messenger.login('email', 'password');
    
    if (!loginResult.success) {
        if (loginResult.requires2FA) {
            console.log('🔒 Two-factor authentication required');
            // Handle 2FA manually
        } else {
            console.log('❌ Login failed:', loginResult.error);
        }
        return;
    }
    
    await messenger.connect();
    
} catch (error) {
    console.error('💥 Connection error:', error.message);
    
    if (error.message.includes('timeout')) {
        console.log('🕐 Connection timeout - check internet connection');
    } else if (error.message.includes('credentials')) {
        console.log('🔑 Invalid credentials - check email/password');
    }
}

🤖 Bot Example

const FacebookMessenger = require('messenger-web-reverse');

class MessengerBot extends FacebookMessenger {
    constructor() {
        super({ debug: true });
        this.setupHandlers();
    }
    
    setupHandlers() {
        this.on('message', this.handleMessage.bind(this));
        this.on('connected', () => {
            console.log('🤖 Bot connected and ready!');
        });
    }
    
    async handleMessage(message) {
        const { from, body } = message;
        
        if (body.startsWith('/help')) {
            await this.sendMessage(from, '🤖 Available commands:\n/help - Show this help\n/time - Get current time\n/echo <text> - Echo your message');
            
        } else if (body.startsWith('/time')) {
            await this.sendMessage(from, `🕐 Current time: ${new Date().toISOString()}`);
            
        } else if (body.startsWith('/echo ')) {
            const text = body.substring(6);
            await this.sendMessage(from, `🔄 Echo: ${text}`);
            
        } else {
            await this.sendMessage(from, '👋 Hello! Type /help for available commands.');
        }
    }
}

// Usage
const bot = new MessengerBot();
await bot.login('[e-mail]', 'bot-password');
await bot.connect();

🎮 Running Examples

Set your Facebook credentials as environment variables:

export FACEBOOK_EMAIL="[e-mail]"
export FACEBOOK_PASSWORD="your-password"
export TARGET_USER_ID="friend-user-id"  # Optional: for testing messages

# Run the example
node examples/real-facebook-messenger.js

With auto-reply enabled:

export AUTO_REPLY="true"
node examples/real-facebook-messenger.js

📁 Project Structure

├── lib/
│   ├── FacebookMessenger.js    # Main client class (NEW)
│   ├── MessengerClient.js      # Legacy modular client
│   ├── auth/                   # Authentication components
│   ├── messaging/              # Message handling
│   ├── websocket/              # WebSocket management
│   └── protocol/               # Protocol parsing
├── examples/
│   ├── real-facebook-messenger.js  # Real Facebook example (NEW)
│   ├── basic-usage.js              # Simple example
│   └── advanced-usage.js           # Advanced bot example
└── README.md

🌟 Key Advantages

✅ Compared to Browser Automation (Puppeteer):

• Much faster - No browser overhead
• Lower resource usage - Minimal memory and CPU
• More reliable - No browser crashes or timeouts
• Cross-platform - Works on servers, Android (Termux), etc.
• Real-time - True WebSocket connection to Facebook

✅ Compared to Unofficial APIs:

• Direct connection - Uses Facebook's real protocols
• Always up-to-date - Adapts to Facebook's changes
• Full feature support - All Messenger features available
• Real authentication - Uses your actual Facebook account

📋 Requirements

• Node.js 14+
• Facebook account with valid credentials
• Internet connection
• No browser required - Pure Node.js implementation

🔧 Troubleshooting & Metode Corecte

⚠️ FOARTE IMPORTANT - Metodele Corecte:

✅ CORECT:

const FacebookMessenger = require('messenger-web-reverse');
const messenger = new FacebookMessenger();
await messenger.login('[e-mail]', 'password');  // ✅ CORECT
await messenger.connect();

❌ GREȘIT:

await client.login('email', 'password');  // ❌ NU FUNCȚIONEAZĂ
await messenger.authenticate('email', 'password');  // ❌ NU FUNCȚIONEAZĂ  

Common Issues:

❌ Login Failed:

• Verify email/password are correct
• Check if account requires 2FA
• Ensure account is not locked/restricted

❌ Connection Timeout:

• Check internet connection
• Verify firewall settings
• Try different network

❌ Session Expired:

• Delete session file: rm facebook_session.json
• Login again with fresh credentials

❌ 2FA Required:

• Currently requires manual handling
• Future versions will support 2FA automation

Debug Mode:

Enable detailed logging:

const messenger = new FacebookMessenger({ debug: true });

🤝 Contributing

Contributions welcome! This library uses reverse-engineered Facebook protocols and benefits from community improvements.

⚖️ Legal & Disclaimer

• Educational/Personal Use: This library is for educational and personal use
• Terms of Service: Use responsibly and comply with Facebook's Terms of Service
• Rate Limits: Respect Facebook's rate limiting and usage policies
• Account Safety: Use with your own accounts and at your own risk

📄 License

MIT License - see LICENSE file for details.

🎯 Made for developers who need real Facebook Messenger integration without browser automation!

🔥 Exemplu Simplu și Rapid

Pentru începători, vezi examples/simple-example.js:

export FACEBOOK_EMAIL="[e-mail]"
export FACEBOOK_PASSWORD="your-password"
node examples/simple-example.js

⚠️ ATENȚIE: Folosește MEREU messenger.login() nu client.login()!