surya-sahil-fca 1.0.0

package/DOCS.md

@@ -0,0 +1,2636 @@
+# FCA-Unofficial - Complete API Documentation
+
+## Introduction
+
+**surya-sahil-fca** is an unofficial Node.js library for interacting with Facebook Messenger by emulating browser behavior. This library allows you to create chat bots and automate tasks on Facebook Messenger.
+
+## Installation
+
+```bash
+npm install surya-sahil-fca@latest
+```
+
+---
+
+## 1. LOGIN
+
+### 1.1. Login with Email & Password
+
+```javascript
+const login = require("surya-sahil-fca");
+
+const credentials = {
+    email: "your_email@example.com",
+    password: "your_password"
+};
+
+login(credentials, (err, api) => {
+    if (err) {
+        console.error("Login error:", err);
+        return;
+    }
+    console.log("Login successful!");
+});
+```
+
+### 1.2. Login with 2FA (Two-Factor Authentication)
+
+When your account has 2FA enabled, you need to provide the 2FA code:
+
+```javascript
+const login = require("surya-sahil-fca");
+const readline = require("readline");
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+const credentials = {
+    email: "your_email@example.com",
+    password: "your_password"
+};
+
+login(credentials, (err, api) => {
+    if (err) {
+        // If 2FA is required
+        if (err.error === 'login-approval') {
+            console.log("2FA code required!");
+
+            rl.question("Enter 2FA code: ", (code) => {
+                err.continue(code);
+                rl.close();
+            });
+        } else {
+            console.error("Login error:", err);
+        }
+        return;
+    }
+
+    console.log("Login successful!");
+});
+```
+
+### 1.3. Login with AppState (Recommended)
+
+AppState is saved cookies and session data. Login with AppState helps avoid entering password each time and reduces checkpoint risk.
+
+#### Get and Save AppState:
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+const credentials = {
+    email: "your_email@example.com",
+    password: "your_password"
+};
+
+login(credentials, (err, api) => {
+    if (err) {
+        console.error("Login error:", err);
+        return;
+    }
+
+    // Save AppState to file
+    try {
+        const appState = api.getAppState();
+        fs.writeFileSync("appstate.json", JSON.stringify(appState, null, 2));
+        console.log("✅ AppState saved!");
+    } catch (error) {
+        console.error("Error saving AppState:", error);
+    }
+});
+```
+
+#### Use Saved AppState:
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+const credentials = {
+    appState: JSON.parse(fs.readFileSync("appstate.json", "utf8"))
+};
+
+login(credentials, (err, api) => {
+    if (err) {
+        console.error("Login error:", err);
+        return;
+    }
+
+    console.log("Login successful with AppState!");
+});
+```
+
+**Note:** You can use [c3c-fbstate](https://github.com/c3cbot/c3c-fbstate) tool to get AppState from browser.
+
+---
+
+## 2. CONFIGURATION (Options)
+
+After login, you can configure API options:
+
+```javascript
+api.setOptions({
+    // Listen to events (add/remove members, change group name, etc.)
+    listenEvents: true,
+
+    // Listen to your own messages
+    selfListen: false,
+
+    // Auto mark messages as read
+    autoMarkRead: false,
+
+    // Auto mark as delivered
+    autoMarkDelivery: false,
+
+    // Online status (true/false)
+    online: true,
+
+    // Log level (silent/error/warn/info/verbose)
+    logLevel: "info",
+
+    // Custom user agent
+    userAgent: "Mozilla/5.0..."
+});
+```
+
+---
+
+## 3. DETAILED API METHODS
+
+### 3.1. sendMessage - Send Message
+
+Send message to user or group chat.
+
+#### Syntax:
+```javascript
+api.sendMessage(message, threadID, [messageID], [callback])
+```
+
+#### Parameters:
+- `message`: Message content (string or object)
+- `threadID`: Conversation ID (user ID or group ID)
+- `messageID`: (Optional) Message ID to reply to
+- `callback`: (Optional) Callback function `(err, messageInfo)`
+
+#### Basic Example:
+
+```javascript
+api.sendMessage("Hello!", "100012345678901", (err, messageInfo) => {
+    if (err) {
+        console.error("Send message error:", err);
+        return;
+    }
+    console.log("Message sent, ID:", messageInfo.messageID);
+});
+```
+
+#### Send Messages with Various Content Types:
+
+```javascript
+// 1. Simple text message
+api.sendMessage("Hello World", threadID);
+
+// 2. Send sticker
+api.sendMessage({
+    sticker: "767334476655547"  // Sticker ID
+}, threadID);
+
+// 3. Send emoji with size
+api.sendMessage({
+    body: "Awesome!",
+    emoji: "👍",
+    emojiSize: "large"  // small, medium, large
+}, threadID);
+
+// 4. Send file/image
+const fs = require("fs");
+api.sendMessage({
+    body: "Here is an image",
+    attachment: fs.createReadStream("./image.jpg")
+}, threadID);
+
+// 5. Send multiple files
+api.sendMessage({
+    body: "Multiple attachments",
+    attachment: [
+        fs.createReadStream("./image1.jpg"),
+        fs.createReadStream("./image2.jpg"),
+        fs.createReadStream("./document.pdf")
+    ]
+}, threadID);
+
+// 6. Send URL
+api.sendMessage({
+    body: "Check this link",
+    url: "https://example.com"
+}, threadID);
+
+// 7. Reply to message
+api.sendMessage({
+    body: "This is a reply"
+}, threadID, messageID);
+
+// 8. Mention users
+api.sendMessage({
+    body: "Hello @User1 and @User2!",
+    mentions: [
+        {
+            tag: "@User1",
+            id: "100012345678901",
+            fromIndex: 6  // Starting position of @User1
+        },
+        {
+            tag: "@User2",
+            id: "100012345678902",
+            fromIndex: 17
+        }
+    ]
+}, threadID);
+```
+
+---
+
+### 3.2. listenMqtt - Listen for Messages
+
+Listen for messages and events from Facebook Messenger (using MQTT).
+
+#### Syntax:
+```javascript
+const stopListening = api.listenMqtt(callback);
+```
+
+#### Parameters:
+- `callback`: Function `(err, event)` called when new message/event arrives
+
+#### Example:
+
+```javascript
+const stopListening = api.listenMqtt((err, event) => {
+    if (err) {
+        console.error("Listen error:", err);
+        return;
+    }
+
+    // Handle events
+    switch (event.type) {
+        case "message":
+            console.log("New message:", event.body);
+            console.log("From user:", event.senderID);
+            console.log("In conversation:", event.threadID);
+
+            // Reply to message
+            if (event.body === "Hi") {
+                api.sendMessage("Hello!", event.threadID);
+            }
+            break;
+
+        case "event":
+            console.log("Event:", event.logMessageType);
+            // log_message_type can be:
+            // - log:subscribe (member added)
+            // - log:unsubscribe (member removed)
+            // - log:thread-name (group name changed)
+            // - log:thread-icon (group icon changed)
+            // - log:thread-color (chat color changed)
+            break;
+
+        case "typ":
+            console.log(event.from, "is typing...");
+            break;
+
+        case "read_receipt":
+            console.log("Message read by:", event.reader);
+            break;
+    }
+});
+
+// Stop listening
+// stopListening();
+```
+
+#### Event Object Details:
+
+```javascript
+// Event type: "message"
+{
+    type: "message",
+    threadID: "1234567890",
+    messageID: "mid.xxx",
+    senderID: "100012345678901",
+    body: "Message content",
+    args: ["Message", "content"],  // Array of words from body (split by whitespace)
+    attachments: [],  // Array of attachments
+    mentions: {},     // Object of mentions
+    timestamp: 1234567890000,
+    isGroup: false,   // true if group chat
+    isUnread: false,  // Whether message is unread
+    participantIDs: ["100012345678901"]  // Array of participant IDs
+}
+
+// Event type: "event"
+{
+    type: "event",
+    threadID: "1234567890",
+    logMessageType: "log:subscribe",
+    logMessageData: {...},
+    author: "100012345678901"
+}
+
+// Event type: "typ" (typing)
+{
+    type: "typ",
+    threadID: "1234567890",
+    from: "100012345678901",
+    isTyping: true
+}
+
+// Event type: "read_receipt" (read)
+{
+    type: "read_receipt",
+    threadID: "1234567890",
+    reader: "100012345678901",
+    time: 1234567890000
+}
+```
+
+---
+
+### 3.3. Middleware System - Filter and Process Events
+
+The middleware system allows you to intercept, filter, and modify events before they are emitted to your callback. This is useful for logging, rate limiting, message filtering, auto-replies, and more.
+
+#### Syntax:
+```javascript
+// Add middleware
+const removeMiddleware = api.useMiddleware(middlewareFunction);
+const removeMiddleware = api.useMiddleware("middlewareName", middlewareFunction);
+
+// Remove middleware
+api.removeMiddleware(identifier); // identifier can be name (string) or function
+
+// Clear all middleware
+api.clearMiddleware();
+
+// List middleware
+const names = api.listMiddleware();
+
+// Enable/disable middleware
+api.setMiddlewareEnabled("middlewareName", true); // enable
+api.setMiddlewareEnabled("middlewareName", false); // disable
+
+// Get middleware count
+const count = api.middlewareCount;
+```
+
+#### Middleware Function Signature:
+```javascript
+function middleware(event, next) {
+    // event: The event object (can be modified)
+    // next: Function to continue to next middleware
+    //   - next() - continue to next middleware
+    //   - next(false) or next(null) - stop processing, don't emit event
+    //   - next(error) - emit error instead
+
+    // Your logic here
+
+    next(); // Continue to next middleware
+}
+```
+
+#### Examples:
+
+**1. Message Filtering - Block messages from specific users:**
+```javascript
+api.useMiddleware("blockUsers", (event, next) => {
+    if (event.type === "message") {
+        const blockedUsers = ["100012345678901", "100012345678902"];
+        if (blockedUsers.includes(event.senderID)) {
+            // Block this message
+            return next(false);
+        }
+    }
+    next(); // Continue processing
+});
+```
+
+**2. Logging Middleware:**
+```javascript
+api.useMiddleware("logger", (event, next) => {
+    if (event.type === "message") {
+        console.log(`[${new Date().toISOString()}] Message from ${event.senderID}: ${event.body}`);
+    }
+    next(); // Continue to next middleware
+});
+```
+
+**3. Auto-Reply Middleware:**
+```javascript
+api.useMiddleware("autoReply", (event, next) => {
+    if (event.type === "message" && event.body.toLowerCase() === "hello") {
+        api.sendMessage("Hi there! How can I help you?", event.threadID);
+    }
+    next(); // Continue processing
+});
+```
+
+**4. Rate Limiting Middleware:**
+```javascript
+const messageCounts = {};
+const RATE_LIMIT = 10; // messages per minute
+const RATE_WINDOW = 60000; // 1 minute
+
+api.useMiddleware("rateLimit", (event, next) => {
+    if (event.type === "message") {
+        const now = Date.now();
+        const senderID = event.senderID;
+
+        // Clean old entries
+        if (messageCounts[senderID] && messageCounts[senderID].timestamp < now - RATE_WINDOW) {
+            delete messageCounts[senderID];
+        }
+
+        // Initialize or increment
+        if (!messageCounts[senderID]) {
+            messageCounts[senderID] = { count: 0, timestamp: now };
+        }
+        messageCounts[senderID].count++;
+
+        // Check rate limit
+        if (messageCounts[senderID].count > RATE_LIMIT) {
+            console.log(`Rate limit exceeded for user ${senderID}`);
+            return next(false); // Block message
+        }
+    }
+    next();
+});
+```
+
+**5. Message Transformation:**
+```javascript
+api.useMiddleware("transform", (event, next) => {
+    if (event.type === "message") {
+        // Add custom property
+        event.customProperty = "customValue";
+
+        // Transform message body
+        if (event.body) {
+            event.body = event.body.toUpperCase();
+        }
+    }
+    next();
+});
+```
+
+**6. Async Middleware (Promise-based):**
+```javascript
+api.useMiddleware("asyncMiddleware", async (event, next) => {
+    if (event.type === "message") {
+        // Do async operation
+        const userInfo = await api.getUserInfo(event.senderID);
+        event.senderName = userInfo[event.senderID].name;
+    }
+    next(); // Continue
+});
+```
+
+**7. Conditional Middleware:**
+```javascript
+// Only process messages in group chats
+api.useMiddleware("groupOnly", (event, next) => {
+    if (event.type === "message" && !event.isGroup) {
+        return next(false); // Skip non-group messages
+    }
+    next();
+});
+
+// Only process messages containing specific keywords
+api.useMiddleware("keywordFilter", (event, next) => {
+    if (event.type === "message") {
+        const keywords = ["help", "support", "info"];
+        const hasKeyword = keywords.some(keyword =>
+            event.body.toLowerCase().includes(keyword)
+        );
+        if (!hasKeyword) {
+            return next(false); // Skip messages without keywords
+        }
+    }
+    next();
+});
+```
+
+**8. Remove Middleware:**
+```javascript
+// Remove by name
+api.removeMiddleware("logger");
+
+// Remove by function reference
+const myMiddleware = (event, next) => { /* ... */ };
+api.useMiddleware("myMiddleware", myMiddleware);
+// Later...
+api.removeMiddleware(myMiddleware);
+```
+
+**9. Complete Example - Bot with Multiple Middleware:**
+```javascript
+const login = require("surya-sahil-fca");
+
+login({ appState: [] }, (err, api) => {
+    if (err) return console.error(err);
+
+    // 1. Logging middleware
+    api.useMiddleware("logger", (event, next) => {
+        if (event.type === "message") {
+            console.log(`Message: ${event.body}`);
+        }
+        next();
+    });
+
+    // 2. Block spam users
+    const spamUsers = ["100012345678901"];
+    api.useMiddleware("spamFilter", (event, next) => {
+        if (event.type === "message" && spamUsers.includes(event.senderID)) {
+            return next(false);
+        }
+        next();
+    });
+
+    // 3. Auto-reply to greetings
+    api.useMiddleware("autoReply", (event, next) => {
+        if (event.type === "message") {
+            const greetings = ["hi", "hello", "hey"];
+            if (greetings.includes(event.body.toLowerCase())) {
+                api.sendMessage("Hello! How can I help?", event.threadID);
+            }
+        }
+        next();
+    });
+
+    // 4. Listen for messages (middleware will process them first)
+    api.listenMqtt((err, event) => {
+        if (err) return console.error(err);
+
+        // This callback receives events AFTER middleware processing
+        if (event.type === "message") {
+            console.log("Received message:", event.body);
+        }
+    });
+});
+```
+
+#### Middleware Execution Order:
+Middleware functions are executed in the order they are added. If a middleware calls `next(false)` or `next(null)`, the event will be blocked and not emitted to your callback.
+
+#### Notes:
+- Middleware only processes events, not errors (errors bypass middleware)
+- You can modify the event object in middleware (it will be passed to the next middleware and callback)
+- Middleware can be async (return a Promise)
+- Middleware can be enabled/disabled without removing them
+- The middleware system is persistent across reconnections
+
+---
+
+### 3.4. getUserInfo - Get User Information
+
+Get detailed information about one or more users.
+
+#### Syntax:
+```javascript
+api.getUserInfo(userID, callback);
+```
+
+#### Example:
+
+```javascript
+// Get info for 1 user
+api.getUserInfo("100012345678901", (err, userInfo) => {
+    if (err) {
+        console.error(err);
+        return;
+    }
+
+    console.log(userInfo);
+    // {
+    //   "100012345678901": {
+    //     name: "John Doe",
+    //     firstName: "John",
+    //     vanity: "john.doe",
+    //     thumbSrc: "avatar_url",
+    //     profileUrl: "https://facebook.com/john.doe",
+    //     gender: "MALE",  // MALE/FEMALE
+    //     type: "user",
+    //     isFriend: true,
+    //     isBirthday: false
+    //   }
+    // }
+});
+
+// Get info for multiple users
+api.getUserInfo(["100012345678901", "100012345678902"], (err, userInfo) => {
+    if (err) return console.error(err);
+
+    for (let id in userInfo) {
+        console.log(userInfo[id].name);
+    }
+});
+```
+
+---
+
+### 3.4. Message Scheduler - Schedule Messages
+
+Schedule messages to be sent at a specific time in the future. Useful for reminders, scheduled announcements, and automated messages.
+
+#### Syntax:
+```javascript
+// Schedule a message
+const id = api.scheduler.scheduleMessage(message, threadID, when, options);
+
+// Cancel a scheduled message
+api.scheduler.cancelScheduledMessage(id);
+
+// Get scheduled message info
+const scheduled = api.scheduler.getScheduledMessage(id);
+
+// List all scheduled messages
+const list = api.scheduler.listScheduledMessages();
+
+// Cancel all scheduled messages
+const count = api.scheduler.cancelAllScheduledMessages();
+
+// Get count of scheduled messages
+const count = api.scheduler.getScheduledCount();
+```
+
+#### Parameters:
+- `message`: Message content (string or MessageObject)
+- `threadID`: Target thread ID(s) (string or array)
+- `when`: When to send - can be:
+  - `Date` object
+  - `number` (Unix timestamp in milliseconds)
+  - `string` (ISO date string)
+- `options`: Optional object with:
+  - `replyMessageID`: Message ID to reply to
+  - `isGroup`: Whether it's a group chat
+  - `callback`: Callback function when message is sent
+
+#### Examples:
+
+**1. Schedule message for specific time:**
+```javascript
+// Schedule for 1 hour from now
+const oneHourLater = Date.now() + (60 * 60 * 1000);
+const id = api.scheduler.scheduleMessage(
+    "This is a scheduled message!",
+    "100012345678901",
+    oneHourLater
+);
+console.log(`Message scheduled with ID: ${id}`);
+```
+
+**2. Schedule using Date object:**
+```javascript
+// Schedule for tomorrow at 9:00 AM
+const tomorrow = new Date();
+tomorrow.setDate(tomorrow.getDate() + 1);
+tomorrow.setHours(9, 0, 0, 0);
+
+const id = api.scheduler.scheduleMessage(
+    "Good morning! ☀️",
+    "100012345678901",
+    tomorrow
+);
+```
+
+**3. Schedule using ISO string:**
+```javascript
+// Schedule for specific date/time
+const id = api.scheduler.scheduleMessage(
+    "Meeting reminder!",
+    "100012345678901",
+    "2024-12-25T10:00:00Z"
+);
+```
+
+**4. Schedule with options:**
+```javascript
+const id = api.scheduler.scheduleMessage(
+    "Reply to your message",
+    "100012345678901",
+    Date.now() + 30000, // 30 seconds from now
+    {
+        replyMessageID: "mid.xxx",
+        isGroup: false,
+        callback: (err) => {
+            if (err) {
+                console.error("Scheduled message failed:", err);
+            } else {
+                console.log("Scheduled message sent!");
+            }
+        }
+    }
+);
+```
+
+**5. Cancel scheduled message:**
+```javascript
+const id = api.scheduler.scheduleMessage("Test", threadID, Date.now() + 60000);
+
+// Cancel it
+if (api.scheduler.cancelScheduledMessage(id)) {
+    console.log("Message cancelled");
+} else {
+    console.log("Message not found or already sent");
+}
+```
+
+**6. List all scheduled messages:**
+```javascript
+const scheduled = api.scheduler.listScheduledMessages();
+
+scheduled.forEach(msg => {
+    const timeUntil = Math.round(msg.timeUntilSend / 1000 / 60); // minutes
+    console.log(`ID: ${msg.id}, Sends in ${timeUntil} minutes`);
+});
+```
+
+**7. Get scheduled message info:**
+```javascript
+const scheduled = api.scheduler.getScheduledMessage(id);
+if (scheduled) {
+    console.log("Message:", scheduled.message);
+    console.log("Scheduled for:", new Date(scheduled.timestamp));
+    console.log("Time until send:", scheduled.timeUntilSend, "ms");
+}
+```
+
+**8. Complete example - Reminder bot:**
+```javascript
+const login = require("surya-sahil-fca");
+
+login({ appState: [] }, (err, api) => {
+    if (err) return console.error(err);
+
+    api.listenMqtt((err, event) => {
+        if (err) return console.error(err);
+
+        if (event.type === "message" && event.body.startsWith("/remind")) {
+            const args = event.body.split(" ");
+            if (args.length < 3) {
+                api.sendMessage("Usage: /remind <minutes> <message>", event.threadID);
+                return;
+            }
+
+            const minutes = parseInt(args[1]);
+            const message = args.slice(2).join(" ");
+            const when = Date.now() + (minutes * 60 * 1000);
+
+            const id = api.scheduler.scheduleMessage(
+                message,
+                event.threadID,
+                when
+            );
+
+            api.sendMessage(
+                `Reminder scheduled! I'll remind you in ${minutes} minutes.`,
+                event.threadID
+            );
+        }
+    });
+});
+```
+
+#### Notes:
+- Scheduled messages are stored in memory and will be lost if the bot restarts
+- Messages are sent automatically at the scheduled time
+- You can cancel messages before they are sent
+- The scheduler automatically cleans up expired messages
+
+---
+
+### 3.5. Auto-save AppState
+
+Automatically save AppState to a file at regular intervals to prevent session loss.
+
+#### Syntax:
+```javascript
+// Enable auto-save
+const disable = api.enableAutoSaveAppState(options);
+
+// Disable auto-save
+disable();
+```
+
+#### Parameters:
+- `options`: Optional object with:
+  - `filePath`: Path to save AppState file (default: "appstate.json")
+  - `interval`: Save interval in milliseconds (default: 10 minutes)
+  - `saveOnLogin`: Save immediately on login (default: true)
+
+#### Examples:
+
+**1. Basic auto-save:**
+```javascript
+const login = require("surya-sahil-fca");
+
+login({ appState: [] }, (err, api) => {
+    if (err) return console.error(err);
+
+    // Enable auto-save (saves every 10 minutes by default)
+    api.enableAutoSaveAppState();
+});
+```
+
+**2. Custom file path and interval:**
+```javascript
+// Save to custom location every 5 minutes
+const disable = api.enableAutoSaveAppState({
+    filePath: "./data/appstate.json",
+    interval: 5 * 60 * 1000, // 5 minutes
+    saveOnLogin: true
+});
+
+// Later, disable it
+// disable();
+```
+
+**3. Save only on login:**
+```javascript
+// Save only once on login, not periodically
+const disable = api.enableAutoSaveAppState({
+    interval: Infinity, // Never save periodically
+    saveOnLogin: true
+});
+```
+
+**4. Complete example:**
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Try to load existing AppState
+let appState = [];
+try {
+    appState = JSON.parse(fs.readFileSync("appstate.json", "utf8"));
+} catch (e) {
+    console.log("No existing AppState found");
+}
+
+login({ appState }, (err, api) => {
+    if (err) return console.error(err);
+
+    // Enable auto-save
+    api.enableAutoSaveAppState({
+        filePath: "appstate.json",
+        interval: 10 * 60 * 1000, // 10 minutes
+        saveOnLogin: true
+    });
+
+    console.log("Bot started with auto-save enabled!");
+});
+```
+
+#### Notes:
+- AppState is saved automatically at the specified interval
+- Saves immediately on login if `saveOnLogin` is true
+- The save function checks if AppState is valid before saving
+- Multiple auto-save instances can be enabled with different settings
+
+---
+
+### 3.6. getThreadInfo - Get Thread Information
+
+Get information about conversation/group chat.
+
+#### Syntax:
+```javascript
+api.getThreadInfo(threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.getThreadInfo("1234567890", (err, threadInfo) => {
+    if (err) {
+        console.error(err);
+        return;
+    }
+
+    console.log("Group name:", threadInfo.threadName);
+    console.log("Member count:", threadInfo.participantIDs.length);
+    console.log("Members list:", threadInfo.participantIDs);
+    console.log("Admins:", threadInfo.adminIDs);
+    console.log("Nicknames:", threadInfo.nicknames);
+    console.log("Chat color:", threadInfo.color);
+    console.log("Emoji:", threadInfo.emoji);
+});
+```
+
+---
+
+### 3.5. changeThreadColor - Change Chat Color
+
+Change the color of conversation.
+
+#### Syntax:
+```javascript
+api.changeThreadColor(color, threadID, callback);
+```
+
+#### Example:
+
+```javascript
+// Color can be:
+// "#0084ff" (Messenger Blue)
+// "#44bec7" (Teal Blue)
+// "#ffc300" (Yellow)
+// "#fa3c4c" (Red)
+// "#d696bb" (Pink)
+// "#6699cc" (Sky Blue)
+// "#13cf13" (Green)
+// "#ff7e29" (Orange)
+// "#e68585" (Light Red)
+// "#7646ff" (Purple)
+// "#20cef5" (Cyan)
+// or any hex color code
+
+api.changeThreadColor("#ffc300", "1234567890", (err) => {
+    if (err) {
+        console.error("Change color error:", err);
+        return;
+    }
+    console.log("Chat color changed successfully!");
+});
+```
+
+---
+
+### 3.6. changeThreadEmoji - Change Group Emoji
+
+Change the default emoji of conversation.
+
+#### Syntax:
+```javascript
+api.changeThreadEmoji(emoji, threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.changeThreadEmoji("👍", "1234567890", (err) => {
+    if (err) {
+        console.error("Change emoji error:", err);
+        return;
+    }
+    console.log("Emoji changed successfully!");
+});
+```
+
+---
+
+### 3.7. setTitle - Change Group Name
+
+Change the name of group chat.
+
+#### Syntax:
+```javascript
+api.setTitle(newTitle, threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.setTitle("New Chat Group", "1234567890", (err) => {
+    if (err) {
+        console.error("Change name error:", err);
+        return;
+    }
+    console.log("Group name changed successfully!");
+});
+```
+
+---
+
+### 3.8. addUserToGroup - Add Member to Group
+
+Add user to group chat.
+
+#### Syntax:
+```javascript
+api.addUserToGroup(userID, threadID, callback);
+```
+
+#### Example:
+
+```javascript
+// Add 1 person
+api.addUserToGroup("100012345678901", "1234567890", (err) => {
+    if (err) {
+        console.error("Add user error:", err);
+        return;
+    }
+    console.log("Member added successfully!");
+});
+
+// Add multiple people
+api.addUserToGroup(["100012345678901", "100012345678902"], "1234567890", (err) => {
+    if (err) return console.error(err);
+    console.log("Multiple members added!");
+});
+```
+
+---
+
+### 3.9. removeUserFromGroup - Remove Member from Group
+
+Remove user from group chat.
+
+#### Syntax:
+```javascript
+api.removeUserFromGroup(userID, threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.removeUserFromGroup("100012345678901", "1234567890", (err) => {
+    if (err) {
+        console.error("Remove user error:", err);
+        return;
+    }
+    console.log("Member removed successfully!");
+});
+```
+
+---
+
+### 3.10. changeNickname - Change Nickname
+
+Change user's nickname in group chat.
+
+#### Syntax:
+```javascript
+api.changeNickname(nickname, threadID, userID, callback);
+```
+
+#### Example:
+
+```javascript
+api.changeNickname("Admin Bot", "1234567890", "100012345678901", (err) => {
+    if (err) {
+        console.error("Change nickname error:", err);
+        return;
+    }
+    console.log("Nickname changed successfully!");
+});
+
+// Remove nickname (set to original name)
+api.changeNickname("", "1234567890", "100012345678901", (err) => {
+    if (err) return console.error(err);
+    console.log("Nickname removed!");
+});
+```
+
+---
+
+### 3.11. markAsRead - Mark as Read
+
+Mark message as read.
+
+#### Syntax:
+```javascript
+api.markAsRead(threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message") {
+        // Auto mark as read
+        api.markAsRead(event.threadID, (err) => {
+            if (err) console.error("Mark as read error:", err);
+        });
+    }
+});
+```
+
+---
+
+### 3.12. markAsDelivered - Mark as Delivered
+
+Mark message as delivered.
+
+#### Syntax:
+```javascript
+api.markAsDelivered(threadID, messageID, callback);
+```
+
+#### Example:
+
+```javascript
+api.markAsDelivered("1234567890", "mid.xxx", (err) => {
+    if (err) {
+        console.error("Mark as delivered error:", err);
+        return;
+    }
+    console.log("Marked as delivered!");
+});
+```
+
+---
+
+### 3.13. markAsReadAll - Mark All as Read
+
+Mark all messages as read.
+
+#### Syntax:
+```javascript
+api.markAsReadAll(callback);
+```
+
+#### Example:
+
+```javascript
+api.markAsReadAll((err) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("All messages marked as read!");
+});
+```
+
+---
+
+### 3.14. sendTypingIndicator - Show Typing Indicator
+
+Display "typing..." status in chat.
+
+#### Syntax:
+```javascript
+api.sendTypingIndicator(threadID, callback);
+```
+
+#### Example:
+
+```javascript
+// Show typing
+api.sendTypingIndicator("1234567890", (err) => {
+    if (err) return console.error(err);
+
+    // After 3 seconds, send message
+    setTimeout(() => {
+        api.sendMessage("Hello!", "1234567890");
+    }, 3000);
+});
+
+// Or stop typing indicator
+api.sendTypingIndicator("1234567890", (err) => {
+    if (err) return console.error(err);
+}, true);  // 3rd parameter is true to turn off typing
+```
+
+---
+
+### 3.15. unsendMessage - Unsend Message
+
+Unsend/recall a sent message.
+
+#### Syntax:
+```javascript
+api.unsendMessage(messageID, callback);
+```
+
+#### Example:
+
+```javascript
+api.sendMessage("This message will be deleted", "1234567890", (err, messageInfo) => {
+    if (err) return console.error(err);
+
+    // Unsend after 5 seconds
+    setTimeout(() => {
+        api.unsendMessage(messageInfo.messageID, (err) => {
+            if (err) {
+                console.error("Unsend error:", err);
+                return;
+            }
+            console.log("Message unsent!");
+        });
+    }, 5000);
+});
+```
+
+---
+
+### 3.16. createPoll - Create Poll
+
+Create poll in group chat.
+
+#### Syntax:
+```javascript
+api.createPoll(title, threadID, options, callback);
+```
+
+#### Example:
+
+```javascript
+const title = "Choose travel destination?";
+const options = {
+    "Da Lat": false,    // false = allow multiple choices
+    "Nha Trang": false,
+    "Phu Quoc": false
+};
+
+api.createPoll(title, "1234567890", options, (err, pollInfo) => {
+    if (err) {
+        console.error("Create poll error:", err);
+        return;
+    }
+    console.log("Poll created successfully!");
+});
+```
+
+---
+
+### 3.17. handleMessageRequest - Handle Message Request
+
+Accept or decline message from stranger.
+
+#### Syntax:
+```javascript
+api.handleMessageRequest(threadID, accept, callback);
+```
+
+#### Example:
+
+```javascript
+// Accept message
+api.handleMessageRequest("1234567890", true, (err) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("Message accepted!");
+});
+
+// Decline message
+api.handleMessageRequest("1234567890", false, (err) => {
+    if (err) return console.error(err);
+    console.log("Message declined!");
+});
+```
+
+---
+
+### 3.18. muteThread - Mute Notifications
+
+Mute or unmute notifications for conversation.
+
+#### Syntax:
+```javascript
+api.muteThread(threadID, muteSeconds, callback);
+```
+
+#### Example:
+
+```javascript
+// Mute for 1 hour (3600 seconds)
+api.muteThread("1234567890", 3600, (err) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("Muted for 1 hour!");
+});
+
+// Mute permanently
+api.muteThread("1234567890", -1, (err) => {
+    if (err) return console.error(err);
+    console.log("Muted permanently!");
+});
+
+// Unmute
+api.muteThread("1234567890", 0, (err) => {
+    if (err) return console.error(err);
+    console.log("Unmuted!");
+});
+```
+
+---
+
+### 3.19. getThreadList - Get Thread List
+
+Get list of conversations.
+
+#### Syntax:
+```javascript
+api.getThreadList(limit, timestamp, tags, callback);
+```
+
+#### Example:
+
+```javascript
+// Get 20 most recent conversations
+api.getThreadList(20, null, ["INBOX"], (err, threads) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+
+    threads.forEach(thread => {
+        console.log("Thread ID:", thread.threadID);
+        console.log("Name:", thread.name);
+        console.log("Unread count:", thread.unreadCount);
+        console.log("Last message:", thread.snippet);
+        console.log("---");
+    });
+});
+
+// Tags can be:
+// - "INBOX" : Inbox
+// - "ARCHIVED" : Archived
+// - "PENDING" : Pending messages
+// - "OTHER" : Other
+```
+
+---
+
+### 3.20. getThreadHistory - Get Message History
+
+Get message history of conversation.
+
+#### Syntax:
+```javascript
+api.getThreadHistory(threadID, amount, timestamp, callback);
+```
+
+#### Example:
+
+```javascript
+// Get 50 most recent messages
+api.getThreadHistory("1234567890", 50, null, (err, history) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+
+    history.forEach(msg => {
+        console.log("From:", msg.senderName);
+        console.log("Content:", msg.body);
+        console.log("Time:", new Date(msg.timestamp));
+        console.log("---");
+    });
+});
+
+// Get older messages (pagination)
+const oldestTimestamp = history[history.length - 1].timestamp;
+api.getThreadHistory("1234567890", 50, oldestTimestamp, (err, olderHistory) => {
+    if (err) return console.error(err);
+    console.log("Retrieved 50 older messages!");
+});
+```
+
+---
+
+### 3.21. getThreadPictures - Get Thread Pictures
+
+Get conversation/group avatar URL.
+
+#### Syntax:
+```javascript
+api.getThreadPictures(threadID, offset, limit, callback);
+```
+
+#### Example:
+
+```javascript
+api.getThreadPictures("1234567890", 0, 10, (err, pictures) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+
+    pictures.forEach(pic => {
+        console.log("Image URL:", pic.url);
+        console.log("Width:", pic.width);
+        console.log("Height:", pic.height);
+    });
+});
+```
+
+---
+
+### 3.22. getUserID - Get User ID
+
+Get User ID from username or profile URL.
+
+#### Syntax:
+```javascript
+api.getUserID(name, callback);
+```
+
+#### Example:
+
+```javascript
+// From username
+api.getUserID("john.doe", (err, data) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("User ID:", data.userID);
+});
+
+// From profile URL
+api.getUserID("https://facebook.com/john.doe", (err, data) => {
+    if (err) return console.error(err);
+    console.log("User ID:", data.userID);
+});
+```
+
+---
+
+### 3.23. getAppState - Get Current AppState
+
+Get current AppState (cookies, session).
+
+#### Syntax:
+```javascript
+const appState = api.getAppState();
+```
+
+#### Example:
+
+```javascript
+const fs = require("fs");
+
+// Get and save AppState
+const appState = api.getAppState();
+fs.writeFileSync("appstate.json", JSON.stringify(appState, null, 2));
+console.log("✅ AppState saved!");
+
+// Periodically update AppState (every 10 minutes)
+setInterval(() => {
+    const updatedAppState = api.getAppState();
+    fs.writeFileSync("appstate.json", JSON.stringify(updatedAppState, null, 2));
+    console.log("🔄 AppState updated");
+}, 10 * 60 * 1000);
+```
+
+---
+
+### 3.24. deleteMessage - Delete Message (from your side)
+
+Delete message from your side (not unsend).
+
+#### Syntax:
+```javascript
+api.deleteMessage(messageID, callback);
+```
+
+#### Example:
+
+```javascript
+api.deleteMessage("mid.xxx", (err) => {
+    if (err) {
+        console.error("Delete message error:", err);
+        return;
+    }
+    console.log("Message deleted!");
+});
+```
+
+---
+
+### 3.25. deleteThread - Delete Thread
+
+Delete conversation from your list.
+
+#### Syntax:
+```javascript
+api.deleteThread(threadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.deleteThread("1234567890", (err) => {
+    if (err) {
+        console.error("Delete thread error:", err);
+        return;
+    }
+    console.log("Thread deleted!");
+});
+```
+
+---
+
+### 3.26. forwardAttachment - Forward Attachment
+
+Forward attachment from one message to another.
+
+#### Syntax:
+```javascript
+api.forwardAttachment(attachmentID, userOrThreadID, callback);
+```
+
+#### Example:
+
+```javascript
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message" && event.attachments.length > 0) {
+        // Forward first attachment
+        const attachmentID = event.attachments[0].ID;
+
+        api.forwardAttachment(attachmentID, "100012345678901", (err) => {
+            if (err) {
+                console.error("Forward error:", err);
+                return;
+            }
+            console.log("Attachment forwarded!");
+        });
+    }
+});
+```
+
+---
+
+### 3.27. setMessageReaction - React to Message
+
+Add reaction (like, love, haha, wow, sad, angry) to message.
+
+#### Syntax:
+```javascript
+api.setMessageReaction(reaction, messageID, callback);
+```
+
+#### Example:
+
+```javascript
+// Reaction can be:
+// "👍" or ":like:" - Like
+// "❤️" or ":love:" - Love
+// "😂" or ":haha:" - Haha
+// "😮" or ":wow:" - Wow
+// "😢" or ":sad:" - Sad
+// "😠" or ":angry:" - Angry
+// "" (empty string) - Remove reaction
+
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message" && event.body === "React me") {
+        api.setMessageReaction("❤️", event.messageID, (err) => {
+            if (err) {
+                console.error("React error:", err);
+                return;
+            }
+            console.log("Message reacted!");
+        });
+    }
+});
+
+// Remove reaction
+api.setMessageReaction("", "mid.xxx", (err) => {
+    if (err) return console.error(err);
+    console.log("Reaction removed!");
+});
+```
+
+---
+
+### 3.28. searchForThread - Search for Thread
+
+Search for conversation by name.
+
+#### Syntax:
+```javascript
+api.searchForThread(name, callback);
+```
+
+#### Example:
+
+```javascript
+api.searchForThread("Study Group", (err, threads) => {
+    if (err) {
+        console.error("Search error:", err);
+        return;
+    }
+
+    threads.forEach(thread => {
+        console.log("Name:", thread.name);
+        console.log("Thread ID:", thread.threadID);
+        console.log("Type:", thread.isGroup ? "Group" : "Personal");
+        console.log("---");
+    });
+});
+```
+
+---
+
+### 3.29. logout - Logout
+
+Logout from Facebook account.
+
+#### Syntax:
+```javascript
+api.logout(callback);
+```
+
+#### Example:
+
+```javascript
+api.logout((err) => {
+    if (err) {
+        console.error("Logout error:", err);
+        return;
+    }
+    console.log("Logged out successfully!");
+});
+```
+
+---
+
+### 3.30. getCurrentUserID - Get Current User ID
+
+Get User ID of currently logged in account.
+
+#### Syntax:
+```javascript
+const myUserID = api.getCurrentUserID();
+```
+
+#### Example:
+
+```javascript
+const myUserID = api.getCurrentUserID();
+console.log("Bot's User ID:", myUserID);
+
+// Use to check if message is from bot
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message") {
+        if (event.senderID === myUserID) {
+            console.log("This is a message from bot!");
+        } else {
+            console.log("Message from someone else");
+        }
+    }
+});
+```
+
+---
+
+### 3.31. resolvePhotoUrl - Get High Quality Photo URL
+
+Get high resolution photo URL from photo ID.
+
+#### Syntax:
+```javascript
+api.resolvePhotoUrl(photoID, callback);
+```
+
+#### Example:
+
+```javascript
+api.resolvePhotoUrl("1234567890123456", (err, url) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("High quality image URL:", url);
+});
+```
+
+---
+
+### 3.32. changeArchivedStatus - Archive/Unarchive Thread
+
+Archive or unarchive conversation.
+
+#### Syntax:
+```javascript
+api.changeArchivedStatus(threadID, archive, callback);
+```
+
+#### Example:
+
+```javascript
+// Archive conversation
+api.changeArchivedStatus("1234567890", true, (err) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("Thread archived!");
+});
+
+// Unarchive
+api.changeArchivedStatus("1234567890", false, (err) => {
+    if (err) return console.error(err);
+    console.log("Thread unarchived!");
+});
+```
+
+---
+
+### 3.33. changeBlockedStatus - Block/Unblock User
+
+Block or unblock user.
+
+#### Syntax:
+```javascript
+api.changeBlockedStatus(userID, block, callback);
+```
+
+#### Example:
+
+```javascript
+// Block user
+api.changeBlockedStatus("100012345678901", true, (err) => {
+    if (err) {
+        console.error("Error:", err);
+        return;
+    }
+    console.log("User blocked!");
+});
+
+// Unblock
+api.changeBlockedStatus("100012345678901", false, (err) => {
+    if (err) return console.error(err);
+    console.log("User unblocked!");
+});
+```
+
+---
+
+### 3.34. createNewGroup - Create New Group
+
+Create new group chat with member list.
+
+#### Syntax:
+```javascript
+api.createNewGroup(participantIDs, groupTitle, callback);
+```
+
+#### Example:
+
+```javascript
+const members = ["100012345678901", "100012345678902", "100012345678903"];
+const groupName = "New Chat Group";
+
+api.createNewGroup(members, groupName, (err, threadID) => {
+    if (err) {
+        console.error("Create group error:", err);
+        return;
+    }
+    console.log("Group created successfully!");
+    console.log("Thread ID:", threadID);
+
+    // Send message to new group
+    api.sendMessage("Welcome to the group!", threadID);
+});
+```
+
+---
+
+## 4. COMPLETE BOT EXAMPLES
+
+### 4.1. Echo Bot (Message Repeater)
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Login
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    (err, api) => {
+        if (err) {
+            console.error("Login error:", err);
+            return;
+        }
+
+        console.log("✅ Bot started!");
+
+        // Configuration
+        api.setOptions({
+            listenEvents: true,
+            selfListen: false,
+            logLevel: "silent"
+        });
+
+        // Listen for messages
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            if (event.type === "message") {
+                const { body, threadID, messageID, senderID } = event;
+
+                // Stop bot command
+                if (body === "/stop") {
+                    api.sendMessage("Bot stopped!", threadID);
+                    process.exit(0);
+                }
+
+                // Echo message
+                api.sendMessage(`📣 Echo: ${body}`, threadID, messageID);
+            }
+        });
+    }
+);
+```
+
+---
+
+### 4.2. Group Management Bot
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Admin list (User IDs)
+const ADMINS = ["100012345678901", "100012345678902"];
+
+// Check admin permission
+function isAdmin(userID) {
+    return ADMINS.includes(userID);
+}
+
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    (err, api) => {
+        if (err) return console.error(err);
+
+        console.log("✅ Group management bot started!");
+
+        api.setOptions({ listenEvents: true });
+
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            const { type, threadID, senderID, body, messageID } = event;
+
+            // Handle messages
+            if (type === "message") {
+                // Only admins can use commands
+                if (!isAdmin(senderID)) {
+                    if (body.startsWith("/")) {
+                        api.sendMessage(
+                            "❌ You don't have permission to use this command!",
+                            threadID,
+                            messageID
+                        );
+                    }
+                    return;
+                }
+
+                // Kick command
+                if (body.startsWith("/kick ")) {
+                    const userID = body.split(" ")[1];
+                    api.removeUserFromGroup(userID, threadID, (err) => {
+                        if (err) {
+                            api.sendMessage("❌ Error kicking user!", threadID);
+                        } else {
+                            api.sendMessage("✅ User kicked!", threadID);
+                        }
+                    });
+                }
+
+                // Rename command
+                else if (body.startsWith("/rename ")) {
+                    const newName = body.substring(8);
+                    api.setTitle(newName, threadID, (err) => {
+                        if (err) {
+                            api.sendMessage("❌ Error renaming group!", threadID);
+                        } else {
+                            api.sendMessage(`✅ Group renamed to: ${newName}`, threadID);
+                        }
+                    });
+                }
+
+                // Group info command
+                else if (body === "/info") {
+                    api.getThreadInfo(threadID, (err, info) => {
+                        if (err) return api.sendMessage("❌ Error getting info!", threadID);
+
+                        const message = `
+📊 GROUP INFORMATION
+━━━━━━━━━━━━━━━
+👥 Name: ${info.threadName}
+📝 Members: ${info.participantIDs.length}
+👑 Admins: ${info.adminIDs.length}
+🎨 Color: ${info.color}
+😊 Emoji: ${info.emoji || "Default"}
+                        `.trim();
+
+                        api.sendMessage(message, threadID);
+                    });
+                }
+
+                // Help command
+                else if (body === "/help") {
+                    const helpMessage = `
+🤖 COMMAND LIST
+━━━━━━━━━━━━━━━
+/kick [userID] - Kick member
+/rename [new name] - Rename group
+/info - View group info
+/help - Show help
+                    `.trim();
+
+                    api.sendMessage(helpMessage, threadID);
+                }
+            }
+
+            // Handle events
+            else if (type === "event") {
+                // Welcome new members
+                if (event.logMessageType === "log:subscribe") {
+                    const addedUsers = event.logMessageData.addedParticipants;
+                    addedUsers.forEach(user => {
+                        api.sendMessage(
+                            `👋 Welcome ${user.fullName} to the group!`,
+                            threadID
+                        );
+                    });
+                }
+
+                // Notify when someone leaves
+                else if (event.logMessageType === "log:unsubscribe") {
+                    api.sendMessage(`👋 Goodbye! A member left the group.`, threadID);
+                }
+            }
+        });
+    }
+);
+```
+
+---
+
+### 4.3. AI ChatBot Style (Mock)
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Store chat history by threadID
+const chatHistory = {};
+
+// Mock AI response function
+function getAIResponse(message, threadID) {
+    // Initialize history if not exists
+    if (!chatHistory[threadID]) {
+        chatHistory[threadID] = [];
+    }
+
+    // Add user message to history
+    chatHistory[threadID].push({ role: "user", content: message });
+
+    // Limit history to last 10 messages
+    if (chatHistory[threadID].length > 10) {
+        chatHistory[threadID] = chatHistory[threadID].slice(-10);
+    }
+
+    // Mock response (you can integrate real ChatGPT API here)
+    let response = "";
+
+    if (message.toLowerCase().includes("hello")) {
+        response = "Hello! How can I help you?";
+    } else if (message.toLowerCase().includes("name")) {
+        response = "I'm an AI Assistant Bot!";
+    } else if (message.toLowerCase().includes("weather")) {
+        response = "Sorry, I don't have weather information. Please check weather apps!";
+    } else {
+        response = `I received your message: "${message}". Thank you for chatting with me!`;
+    }
+
+    // Add response to history
+    chatHistory[threadID].push({ role: "assistant", content: response });
+
+    return response;
+}
+
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    (err, api) => {
+        if (err) return console.error(err);
+
+        console.log("✅ AI Bot started!");
+
+        api.setOptions({
+            listenEvents: true,
+            selfListen: false
+        });
+
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            if (event.type === "message" && event.body) {
+                const { body, threadID, messageID } = event;
+
+                // Ignore if doesn't start with "ai" prefix
+                if (!body.toLowerCase().startsWith("ai ")) {
+                    return;
+                }
+
+                // Get message content (remove "ai " prefix)
+                const userMessage = body.substring(3).trim();
+
+                // Show typing indicator
+                api.sendTypingIndicator(threadID);
+
+                // Delay for more natural feel
+                setTimeout(() => {
+                    const aiResponse = getAIResponse(userMessage, threadID);
+                    api.sendMessage(`🤖 ${aiResponse}`, threadID, messageID);
+                }, 1500);
+            }
+        });
+    }
+);
+```
+
+---
+
+### 4.4. Auto-Reply Bot with Keywords
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Auto-reply dictionary
+const autoReplies = {
+    "hello": "Hi there! How can I help you?",
+    "hi": "Hello! What's up?",
+    "bye": "Goodbye! See you later!",
+    "thanks": "You're welcome! 😊",
+    "help": "I'm here to assist! Just ask me anything.",
+    "time": () => `Current time: ${new Date().toLocaleTimeString()}`,
+    "date": () => `Today's date: ${new Date().toLocaleDateString()}`
+};
+
+function getAutoReply(message) {
+    const lowerMessage = message.toLowerCase().trim();
+
+    // Check for exact matches
+    for (let keyword in autoReplies) {
+        if (lowerMessage.includes(keyword)) {
+            const reply = autoReplies[keyword];
+            // If reply is function, execute it
+            return typeof reply === 'function' ? reply() : reply;
+        }
+    }
+
+    return null; // No match found
+}
+
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    (err, api) => {
+        if (err) return console.error(err);
+
+        console.log("✅ Auto-reply bot started!");
+
+        api.setOptions({
+            listenEvents: true,
+            selfListen: false
+        });
+
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            if (event.type === "message" && event.body) {
+                const { body, threadID, messageID } = event;
+
+                const reply = getAutoReply(body);
+
+                if (reply) {
+                    api.sendMessage(reply, threadID, messageID);
+                }
+            }
+        });
+    }
+);
+```
+
+---
+
+### 4.5. Command Handler Bot
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+// Command prefix
+const PREFIX = "/";
+
+// Commands object
+const commands = {
+    ping: {
+        description: "Check bot latency",
+        execute: (api, event) => {
+            const start = Date.now();
+            api.sendMessage("Pong! 🏓", event.threadID, (err) => {
+                if (!err) {
+                    const latency = Date.now() - start;
+                    api.sendMessage(`Latency: ${latency}ms`, event.threadID);
+                }
+            });
+        }
+    },
+
+    userinfo: {
+        description: "Get user information",
+        execute: (api, event) => {
+            api.getUserInfo(event.senderID, (err, userInfo) => {
+                if (err) return api.sendMessage("Error getting user info!", event.threadID);
+
+                const user = userInfo[event.senderID];
+                const info = `
+👤 USER INFO
+━━━━━━━━━━━━
+Name: ${user.name}
+Gender: ${user.gender}
+Profile: ${user.profileUrl}
+                `.trim();
+
+                api.sendMessage(info, event.threadID);
+            });
+        }
+    },
+
+    time: {
+        description: "Get current time",
+        execute: (api, event) => {
+            const now = new Date();
+            api.sendMessage(`🕐 Current time: ${now.toLocaleString()}`, event.threadID);
+        }
+    },
+
+    help: {
+        description: "Show command list",
+        execute: (api, event) => {
+            let helpText = "📋 AVAILABLE COMMANDS\n━━━━━━━━━━━━━━━\n";
+
+            for (let cmd in commands) {
+                helpText += `${PREFIX}${cmd} - ${commands[cmd].description}\n`;
+            }
+
+            api.sendMessage(helpText, event.threadID);
+        }
+    }
+};
+
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    (err, api) => {
+        if (err) return console.error(err);
+
+        console.log("✅ Command handler bot started!");
+
+        api.setOptions({ listenEvents: true, selfListen: false });
+
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            if (event.type === "message" && event.body) {
+                const { body, threadID } = event;
+
+                // Check if message starts with prefix
+                if (!body.startsWith(PREFIX)) return;
+
+                // Parse command
+                const args = body.slice(PREFIX.length).trim().split(/ +/);
+                const commandName = args.shift().toLowerCase();
+
+                // Execute command
+                if (commands[commandName]) {
+                    try {
+                        commands[commandName].execute(api, event, args);
+                    } catch (error) {
+                        console.error("Command execution error:", error);
+                        api.sendMessage("Error executing command!", threadID);
+                    }
+                } else {
+                    api.sendMessage(`Unknown command: ${commandName}\nUse ${PREFIX}help for command list`, threadID);
+                }
+            }
+        });
+    }
+);
+```
+
+---
+
+## 5. ERROR HANDLING & BEST PRACTICES
+
+### 5.1. Handle Checkpoint/Security Check
+
+When Facebook detects unusual activity, account may be checkpointed:
+
+```javascript
+login(credentials, (err, api) => {
+    if (err) {
+        switch (err.error) {
+            case "login-approval":
+                console.log("❗ 2FA code required");
+                // Handle 2FA
+                break;
+
+            case "checkpoint":
+                console.log("❌ Account checkpointed!");
+                console.log("Please login via browser and verify");
+                break;
+
+            default:
+                console.error("Login error:", err);
+        }
+        return;
+    }
+});
+```
+
+---
+
+### 5.2. Auto-save AppState
+
+```javascript
+// Save AppState every 10 minutes
+setInterval(() => {
+    try {
+        const appState = api.getAppState();
+        fs.writeFileSync("appstate.json", JSON.stringify(appState, null, 2));
+        console.log("🔄 AppState updated");
+    } catch (error) {
+        console.error("Error saving AppState:", error);
+    }
+}, 10 * 60 * 1000);
+```
+
+---
+
+### 5.3. Connection Error Handling
+
+```javascript
+api.listenMqtt((err, event) => {
+    if (err) {
+        console.error("Listen error:", err);
+
+        // Retry connection after 5 seconds
+        setTimeout(() => {
+            console.log("🔄 Reconnecting...");
+            api.listenMqtt(arguments.callee);
+        }, 5000);
+        return;
+    }
+
+    // Handle events normally
+});
+```
+
+---
+
+### 5.4. Rate Limiting (Avoid Spam)
+
+```javascript
+const MESSAGE_COOLDOWN = {}; // Store last message time
+
+function canSendMessage(threadID, cooldownTime = 1000) {
+    const now = Date.now();
+    const lastTime = MESSAGE_COOLDOWN[threadID] || 0;
+
+    if (now - lastTime < cooldownTime) {
+        return false;
+    }
+
+    MESSAGE_COOLDOWN[threadID] = now;
+    return true;
+}
+
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message") {
+        // Check cooldown
+        if (!canSendMessage(event.threadID, 2000)) {
+            console.log("⏱️  On cooldown...");
+            return;
+        }
+
+        // Handle message
+        api.sendMessage("Response", event.threadID);
+    }
+});
+```
+
+---
+
+### 5.5. Logging and Debug
+
+```javascript
+// Enable detailed logging
+api.setOptions({
+    logLevel: "verbose"  // silent/error/warn/info/verbose
+});
+
+// Custom logger
+function log(type, message, data = {}) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] [${type.toUpperCase()}] ${message}`, data);
+}
+
+api.listenMqtt((err, event) => {
+    if (err) {
+        log("error", "Listen error", err);
+        return;
+    }
+
+    log("info", "New event", {
+        type: event.type,
+        threadID: event.threadID
+    });
+});
+```
+
+---
+
+### 5.6. Environment Variables for Credentials
+
+```javascript
+require('dotenv').config();
+
+const credentials = {
+    email: process.env.FB_EMAIL,
+    password: process.env.FB_PASSWORD
+};
+
+// Or use AppState
+const credentials = {
+    appState: JSON.parse(fs.readFileSync(process.env.APPSTATE_PATH, "utf8"))
+};
+```
+
+**.env file:**
+```
+FB_EMAIL=your_email@example.com
+FB_PASSWORD=your_password
+APPSTATE_PATH=./appstate.json
+```
+
+---
+
+## 6. IMPORTANT NOTES
+
+### ⚠️ Security Warnings
+
+1. **Never share AppState**: The `appstate.json` file contains login information, never make it public
+2. **Use .gitignore**: Add `appstate.json` to `.gitignore`
+3. **Avoid hardcoding passwords**: Use environment variables or config files
+4. **Keep dependencies updated**: Regularly update the package
+
+### 📝 Best Practices
+
+1. **Use AppState instead of email/password**: Reduces checkpoint risk
+2. **Don't spam**: Avoid sending too many messages in short time
+3. **Complete error handling**: Always have callbacks to handle errors
+4. **Rate limiting**: Limit number of messages/requests
+5. **Log activities**: Keep logs for debugging
+
+### 🚫 Avoid Getting Banned
+
+- Don't login/logout repeatedly
+- Don't mass message strangers
+- Don't send spam links
+- Use real browser User-Agent
+- Limit requests per minute
+- Be a responsible Facebook citizen
+
+---
+
+## 7. TROUBLESHOOTING
+
+### Error: "Wrong username/password"
+- Check email and password
+- Try logging in manually via browser
+- Account may be checkpointed
+
+### Error: "Login approval needed"
+- Account has 2FA enabled
+- Provide 2FA verification code
+
+### Error: "Checkpoint required"
+- Login to Facebook via browser
+- Complete verification steps
+- Get new AppState after verification
+
+### Bot not receiving messages
+- Check internet connection
+- Check logs for detailed errors
+- Try restarting bot
+- Update AppState
+
+### Messages sending too slowly
+- Implement message queue
+- Use rate limiting
+- Check network latency
+
+---
+
+## 8. ADVANCED FEATURES
+
+### 8.1. Message Queue System
+
+```javascript
+class MessageQueue {
+    constructor(api) {
+        this.api = api;
+        this.queue = [];
+        this.processing = false;
+        this.delay = 1000; // 1 second delay between messages
+    }
+
+    add(message, threadID, messageID) {
+        this.queue.push({ message, threadID, messageID });
+        if (!this.processing) {
+            this.process();
+        }
+    }
+
+    async process() {
+        this.processing = true;
+
+        while (this.queue.length > 0) {
+            const { message, threadID, messageID } = this.queue.shift();
+
+            await new Promise((resolve) => {
+                this.api.sendMessage(message, threadID, messageID, (err) => {
+                    if (err) console.error("Send error:", err);
+                    setTimeout(resolve, this.delay);
+                });
+            });
+        }
+
+        this.processing = false;
+    }
+}
+
+// Usage
+const messageQueue = new MessageQueue(api);
+
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message") {
+        messageQueue.add("Response", event.threadID, event.messageID);
+    }
+});
+```
+
+---
+
+### 8.2. Multi-Account Bot Manager
+
+```javascript
+const fs = require("fs");
+const login = require("surya-sahil-fca");
+
+class BotManager {
+    constructor() {
+        this.bots = new Map();
+    }
+
+    async addBot(name, appStatePath) {
+        return new Promise((resolve, reject) => {
+            const credentials = {
+                appState: JSON.parse(fs.readFileSync(appStatePath, "utf8"))
+            };
+
+            login(credentials, (err, api) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+
+                this.bots.set(name, api);
+                console.log(`✅ Bot "${name}" connected`);
+                resolve(api);
+            });
+        });
+    }
+
+    getBot(name) {
+        return this.bots.get(name);
+    }
+
+    getAllBots() {
+        return Array.from(this.bots.values());
+    }
+}
+
+// Usage
+const manager = new BotManager();
+
+(async () => {
+    await manager.addBot("bot1", "./appstate1.json");
+    await manager.addBot("bot2", "./appstate2.json");
+
+    const bot1 = manager.getBot("bot1");
+    const bot2 = manager.getBot("bot2");
+
+    // Use bots independently
+    bot1.sendMessage("Message from Bot 1", threadID);
+    bot2.sendMessage("Message from Bot 2", threadID);
+})();
+```
+
+---
+
+### 8.3. Database Integration (SQLite Example)
+
+```javascript
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('./bot.db');
+
+// Initialize database
+db.serialize(() => {
+    db.run(`CREATE TABLE IF NOT EXISTS users (
+        user_id TEXT PRIMARY KEY,
+        username TEXT,
+        message_count INTEGER DEFAULT 0,
+        last_interaction TEXT
+    )`);
+});
+
+// Track user messages
+function trackUser(userID, username) {
+    db.run(`
+        INSERT INTO users (user_id, username, message_count, last_interaction)
+        VALUES (?, ?, 1, datetime('now'))
+        ON CONFLICT(user_id) DO UPDATE SET
+            message_count = message_count + 1,
+            last_interaction = datetime('now')
+    `, [userID, username]);
+}
+
+// Get user stats
+function getUserStats(userID, callback) {
+    db.get('SELECT * FROM users WHERE user_id = ?', [userID], callback);
+}
+
+// Usage in bot
+api.listenMqtt((err, event) => {
+    if (err) return console.error(err);
+
+    if (event.type === "message") {
+        // Track user
+        api.getUserInfo(event.senderID, (err, info) => {
+            if (!err) {
+                const username = info[event.senderID].name;
+                trackUser(event.senderID, username);
+            }
+        });
+
+        // Stats command
+        if (event.body === "/stats") {
+            getUserStats(event.senderID, (err, row) => {
+                if (err || !row) return;
+
+                const stats = `
+📊 YOUR STATS
+━━━━━━━━━━━━
+Messages: ${row.message_count}
+Last seen: ${row.last_interaction}
+                `.trim();
+
+                api.sendMessage(stats, event.threadID);
+            });
+        }
+    }
+});
+```
+
+---
+
+## 9. RESOURCES
+
+- **GitHub Repository**: https://github.com/surya-sahil/fca-unofficial
+- **NPM Package**: surya-sahil-fca
+- **AppState Tool**: https://github.com/c3cbot/c3c-fbstate
+- **Facebook Developer Docs**: https://developers.facebook.com/docs/messenger-platform
+
+---
+
+## Conclusion
+
+This is a comprehensive documentation for **surya-sahil-fca** API methods. This library is very powerful but should be used carefully to avoid violating Facebook's policies and getting your account banned.
+
+**Happy bot coding! 🚀**