shadowx-fca 2.4.0 → 2.5.0

package/package.json

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

package/src/GetBotInfo.js

@@ -0,0 +1,57 @@
+"use strict";
+// sahilchat-fca — GetBotInfo
+// Author: S4hiilAns4ri (github.com/S4hiilAns4ri)
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  /**
+   * Returns bot's current login info, tokens, and context accessor functions.
+   * @param {Array<object>} netData - JSON blobs extracted from Facebook HTML
+   * @returns {object|null}
+   */
+  return function GetBotInfo(netData) {
+    if (!netData || !Array.isArray(netData)) {
+      utils.error("GetBotInfo", "netData is not a valid array.");
+      return null;
+    }
+
+    const findConfig = (key) => {
+      for (const scriptData of netData) {
+        if (!scriptData.require) continue;
+        for (const req of scriptData.require) {
+          if (Array.isArray(req) && req[0] === key && req[2]) return req[2];
+          if (Array.isArray(req) && req[3]?.[0]?.__bbox?.define) {
+            for (const def of req[3][0].__bbox.define) {
+              if (Array.isArray(def) && def[0].endsWith(key) && def[2]) return def[2];
+            }
+          }
+        }
+      }
+      return null;
+    };
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const dtsgInitialData = findConfig("DTSGInitialData");
+    const dtsgInitData    = findConfig("DTSGInitData");
+    const lsdData         = findConfig("LSD");
+
+    if (!currentUserData || !dtsgInitialData) {
+      utils.error("GetBotInfo", "Could not find required data (CurrentUserInitialData or DTSGInitialData).");
+      return null;
+    }
+
+    return {
+      name      : currentUserData.NAME,
+      firstName : currentUserData.SHORT_NAME,
+      uid       : currentUserData.USER_ID,
+      appID     : currentUserData.APP_ID,
+      dtsgToken : dtsgInitialData.token,
+      lsdToken  : lsdData?.token,
+      dtsgInit  : dtsgInitData ? { token: dtsgInitData.token, async_get_token: dtsgInitData.async_get_token } : undefined,
+      getCtx     : (key) => ctx[key],
+      getOptions : (key) => ctx.globalOptions[key],
+      getRegion  : () => ctx?.region,
+    };
+  };
+};

package/src/OldMessage.js

@@ -311,19 +311,47 @@ module.exports = function (defaultFuncs, api, ctx) {
     };
     // console.log(form)
 
-    handleLocation(msg, form, callback, () =>
-      handleSticker(msg, form, callback, () =>
-        handleAttachment(msg, form, callback, () =>
-          handleUrl(msg, form, callback, () =>
-            handleEmoji(msg, form, callback, () =>
-              handleMention(msg, form, callback, () =>
-                send(form, threadID, messageAndOTID, callback, isGroup)
+    const configSource = (global.GoatBot && global.GoatBot.config) ? global.GoatBot.config : ctx.config || {};
+    const enableTypingIndicator = typeof configSource.enableTypingIndicator !== 'undefined' ? configSource.enableTypingIndicator : ctx.config?.enableTypingIndicator;
+    const typingDuration = Number(configSource.typingDuration || ctx.config?.typingDuration || 4000);
+
+    if (enableTypingIndicator) {
+        api.sendTypingIndicator(true, threadID, () => {});
+        const originalCallback = callback;
+        callback = (err, data) => {
+            api.sendTypingIndicator(false, threadID, () => {});
+            originalCallback(err, data);
+        };
+        setTimeout(() => {
+            handleLocation(msg, form, callback, () =>
+              handleSticker(msg, form, callback, () =>
+                handleAttachment(msg, form, callback, () =>
+                  handleUrl(msg, form, callback, () =>
+                    handleEmoji(msg, form, callback, () =>
+                      handleMention(msg, form, callback, () =>
+                        sendContent(form, threadID, isSingleUser, messageAndOTID, callback)
+                      )
+                    )
+                  )
+                )
+              )
+            );
+        }, typingDuration);
+    } else {
+        handleLocation(msg, form, callback, () =>
+          handleSticker(msg, form, callback, () =>
+            handleAttachment(msg, form, callback, () =>
+              handleUrl(msg, form, callback, () =>
+                handleEmoji(msg, form, callback, () =>
+                  handleMention(msg, form, callback, () =>
+                    sendContent(form, threadID, isSingleUser, messageAndOTID, callback)
+                  )
+                )
               )
             )
           )
-        )
-      )
-    );
+        );
+    }
     return returnPromise;
   };
 };

package/src/comment.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const utils = require('../utils');
+
+/**
+ * Handles the upload of attachments (images/videos) for a comment.
+ * @param {object} defaultFuncs - The default functions for making API requests.
+ * @param {object} ctx - The context object.
+ * @param {object} msg - The message object, containing attachments.
+ * @param {object} form - The main form object to be populated.
+ * @returns {Promise<void>}
+ */
+async function handleUpload(defaultFuncs, ctx, msg, form) {
+    if (!msg.attachments || msg.attachments.length === 0) {
+        return;
+    }
+
+    const uploads = msg.attachments.map(item => {
+        if (!utils.isReadableStream(item)) {
+            throw new Error('Attachments must be a readable stream.');
+        }
+        return defaultFuncs
+            .postFormData('https://www.facebook.com/ajax/ufi/upload/', ctx.jar, {
+                profile_id: ctx.userID,
+                source: 19,
+                target_id: ctx.userID,
+                file: item
+            })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(res => {
+                if (res.error || !res.payload?.fbid) {
+                    throw res;
+                }
+                return { media: { id: res.payload.fbid } };
+            });
+    });
+
+    const results = await Promise.all(uploads);
+    form.input.attachments.push(...results);
+}
+
+/**
+ * Handles a URL attachment for a comment.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleURL(msg, form) {
+    if (typeof msg.url === 'string') {
+        form.input.attachments.push({
+            link: {
+                external: {
+                    url: msg.url
+                }
+            }
+        });
+    }
+}
+
+/**
+ * Handles mentions in the comment body.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleMentions(msg, form) {
+    if (!msg.mentions) return;
+
+    for (const item of msg.mentions) {
+        const { tag, id, fromIndex } = item;
+        if (typeof tag !== 'string' || !id) {
+            utils.warn('createCommentPost', 'Mentions must have a string "tag" and an "id".');
+            continue;
+        }
+        const offset = msg.body.indexOf(tag, fromIndex || 0);
+        if (offset < 0) {
+            utils.warn('createCommentPost', `Mention for "${tag}" not found in message string.`);
+            continue;
+        }
+        form.input.message.ranges.push({
+            entity: { id },
+            length: tag.length,
+            offset
+        });
+    }
+}
+
+/**
+ * Handles a sticker attachment for a comment.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleSticker(msg, form) {
+    if (msg.sticker) {
+        form.input.attachments.push({
+            media: {
+                id: String(msg.sticker)
+            }
+        });
+    }
+}
+
+/**
+ * Submits the final comment form to the GraphQL endpoint.
+ * @param {object} defaultFuncs - The default functions.
+ * @param {object} ctx - The context object.
+ * @param {object} form - The fully constructed form object.
+ * @returns {Promise<object>} A promise that resolves with the comment info.
+ */
+async function createContent(defaultFuncs, ctx, form) {
+    const res = await defaultFuncs
+        .post('https://www.facebook.com/api/graphql/', ctx.jar, {
+            fb_api_caller_class: 'RelayModern',
+            fb_api_req_friendly_name: 'useCometUFICreateCommentMutation',
+            variables: JSON.stringify(form),
+            server_timestamps: true,
+            doc_id: 6993516810709754
+        })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    // Hard error from Facebook — comment was NOT sent
+    if (res.errors && res.errors.length > 0) {
+        throw new Error(res.errors[0].message || JSON.stringify(res.errors[0]));
+    }
+
+    // Try to extract comment info from response
+    try {
+        const commentEdge = res?.data?.comment_create?.feedback_comment_edge;
+        const id    = commentEdge?.node?.id    || null;
+        const url   = commentEdge?.node?.feedback?.url || null;
+        const count = res?.data?.comment_create?.feedback?.total_comment_count || 0;
+        return { id, url, count };
+    } catch (_) {
+        // Comment went through but response structure was unexpected — still a success
+        return { id: null, url: null, count: 0 };
+    }
+}
+
+/**
+ * Creates a comment on a Facebook post. Can also reply to an existing comment.
+ * @param {string|object} msg - The message to post. Can be a string or an object with `body`, `attachments`, `mentions`, etc.
+ * @param {string} postID - The ID of the post to comment on.
+ * @param {string} [replyCommentID] - (Optional) The ID of the comment to reply to.
+ * @param {function} [callback] - (Optional) A callback function.
+ * @returns {Promise<object>} A promise that resolves with the new comment's information.
+ */
+module.exports = function(defaultFuncs, api, ctx) {
+    return async function createCommentPost(msg, postID, replyCommentID, callback) {
+        let cb;
+        const returnPromise = new Promise((resolve, reject) => {
+            cb = (error, info) => info ? resolve(info) : reject(error);
+        });
+
+        if (typeof replyCommentID === 'function') {
+            callback = replyCommentID;
+            replyCommentID = null;
+        }
+        if (typeof callback === 'function') {
+            cb = callback;
+        }
+
+        if (typeof msg !== 'string' && typeof msg !== 'object') {
+            const error = 'Message must be a string or an object.';
+            utils.error('createCommentPost', error);
+            return cb(error);
+        }
+        if (typeof postID !== 'string') {
+            const error = 'postID must be a string.';
+            utils.error('createCommentPost', error);
+            return cb(error);
+        }
+
+        let messageObject = typeof msg === 'string' ? { body: msg } : { ...msg };
+        messageObject.mentions = messageObject.mentions || [];
+        messageObject.attachments = messageObject.attachments || [];
+        
+        const form = {
+            feedLocation: 'NEWSFEED',
+            feedbackSource: 1,
+            groupID: null,
+            input: {
+                client_mutation_id: Math.round(Math.random() * 19).toString(),
+                actor_id: ctx.userID,
+                attachments: [],
+                feedback_id: Buffer.from('feedback:' + postID).toString('base64'),
+                message: {
+                    ranges: [],
+                    text: messageObject.body || ''
+                },
+                reply_comment_parent_fbid: replyCommentID || null,
+                is_tracking_encrypted: true,
+                tracking: [],
+                feedback_source: 'NEWS_FEED',
+                idempotence_token: 'client:' + utils.getGUID(),
+                session_id: utils.getGUID()
+            },
+            scale: 1,
+            useDefaultActor: false
+        };
+
+        try {
+            await handleUpload(defaultFuncs, ctx, messageObject, form);
+            handleURL(messageObject, form);
+            handleMentions(messageObject, form);
+            handleSticker(messageObject, form);
+            const info = await createContent(defaultFuncs, ctx, form);
+            cb(null, info);
+        } catch (err) {
+            utils.error('createCommentPost', err);
+            cb(err);
+        }
+
+        return returnPromise;
+    };
+};

package/src/emoji.js

@@ -0,0 +1,124 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Author: S4hiilAns4ri (github.com/S4hiilAns4ri)
+   * Mqtt
+   * Sets the custom emoji for a specific Facebook thread via MQTT.
+   *
+   * @param {string} emoji The emoji character to set as the custom emoji (e.g., "👍", "❤️").
+   * @param {string} threadID The ID of the thread where the emoji will be set.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the emoji change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function emoji(emoji, threadID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        _resolvePromise = resolve;
+        _rejectPromise = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set an emoji."));
+    }
+    if (!emoji) {
+      return _callback(new Error("An emoji character is required."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      custom_emoji: emoji,
+      avatar_sticker_instruction_key_id: null,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '100003',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_quick_reaction',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        return _callback(new Error(`MQTT publish failed for emoji: ${err.message || err}`));
+      }
+      
+      const emojiChangeEvent = {
+        type: "thread_emoji_update",
+        threadID: threadID,
+        newEmoji: emoji,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, emojiChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};