surya-sahil-fca 1.0.0

package/module/options.js

@@ -0,0 +1,45 @@
+const { getType } = require("../src/utils/format");
+const { setProxy } = require("../src/utils/request");
+const logger = require("../func/logger");
+const Boolean_Option = [
+  "online",
+  "selfListen",
+  "listenEvents",
+  "updatePresence",
+  "forceLogin",
+  "autoMarkDelivery",
+  "autoMarkRead",
+  "listenTyping",
+  "autoReconnect",
+  "emitReady",
+  "selfListenEvent"
+];
+function setOptions(globalOptions, options) {
+  for (const key of Object.keys(options || {})) {
+    if (Boolean_Option.includes(key)) {
+      globalOptions[key] = Boolean(options[key]);
+      continue;
+    }
+    switch (key) {
+      case "userAgent": {
+        globalOptions.userAgent = options.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
+        break;
+      }
+      case "proxy": {
+        if (typeof options.proxy !== "string") {
+          delete globalOptions.proxy;
+          setProxy();
+        } else {
+          globalOptions.proxy = options.proxy;
+          setProxy(globalOptions.proxy);
+        }
+        break;
+      }
+      default: {
+        logger("setOptions Unrecognized option given to setOptions: " + key, "warn");
+        break;
+      }
+    }
+  }
+}
+module.exports = { setOptions, Boolean_Option };

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "surya-sahil-fca",
+  "version": "1.0.0",
+  "description": "Facebook Chat API - Streamlined version with essential features",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "mocha",
+    "lint": "eslint ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/surya-sahil/fca.git"
+  },
+  "keywords": [
+    "facebook",
+    "chat",
+    "api",
+    "messenger",
+    "bot",
+    "unofficial",
+    "automation",
+    "facebook-api",
+    "facebook-chat",
+    "facebook-messenger",
+    "chatbot",
+    "nodejs",
+    "fca"
+  ],
+  "author": {
+    "name": "Surya Sahil",
+    "url": "https://github.com/surya-sahil"
+  },
+  "contributors": [
+    {
+      "name": "Surya Sahil",
+      "url": "https://github.com/surya-sahil"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/surya-sahil/fca/issues"
+  },
+  "homepage": "https://github.com/surya-sahil/fca#readme",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "dependencies": {
+    "axios": "latest",
+    "axios-cookiejar-support": "^5.0.5",
+    "bluebird": "^3.7.2",
+    "chalk": "^4.1.2",
+    "cheerio": "^1.0.0-rc.10",
+    "duplexify": "^4.1.3",
+    "gradient-string": "^2.0.2",
+    "https-proxy-agent": "^4.0.0",
+    "mqtt": "^4.3.8",
+    "npmlog": "^1.2.0",
+    "request": "^2.53.0",
+    "sequelize": "^6.37.6",
+    "sqlite3": "^5.1.7",
+    "totp-generator": "^1.0.0",
+    "ws": "^8.18.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0",
+    "mocha": "^10.2.0"
+  },
+  "optionalDependencies": {},
+  "peerDependencies": {},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/api/messaging/changeGroupImage.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function handleUpload(image) {
+    const form = {
+      images_only: "true",
+      "attachment[]": image
+    };
+    return defaultFuncs
+      .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) throw resData;
+        return resData.payload.metadata[0];
+      });
+  }
+  return function changeGroupImage(image, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || typeof threadID !== "string") {
+        const err = new Error("Invalid threadID");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      handleUpload(image)
+        .then(payload => {
+          const imageID = payload.image_id;
+          const taskPayload = {
+            thread_key: threadID,
+            image_id: imageID,
+            sync_group: 1
+          };
+
+          const mqttPayload = {
+            epoch_id: generateOfflineThreadingID(),
+            tasks: [
+              {
+                failure_count: null,
+                label: "37",
+                payload: JSON.stringify(taskPayload),
+                queue_name: "thread_image",
+                task_id: taskID
+              }
+            ],
+            version_id: "8798795233522156"
+          };
+          const request = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify(mqttPayload),
+            request_id: reqID,
+            type: 3
+          };
+          ctx.mqttClient.publish("/ls_req", JSON.stringify(request), {
+            qos: 1,
+            retain: false
+          });
+        })
+        .catch(err => {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeGroupImageMqtt", err);
+          callback?.(err);
+          reject(err);
+        });
+    });
+  };
+};

package/src/api/messaging/changeNickname.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeNickname(nickname, threadID, participantID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || !participantID) {
+        const err = new Error("Missing required parameters");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "44",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_id: participantID,
+              nickname: nickname || "",
+              sync_group: 1
+            }),
+            queue_name: "thread_participant_nickname",
+            task_id: taskID
+          }
+        ],
+        version_id: "8798795233522156"
+      };
+      const request = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      };
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(request), { qos: 1, retain: false }, (err) => {
+        if (err) {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeNicknameMqtt", err);
+          callback?.(err);
+          return reject(err);
+        }
+      });
+    });
+  };
+};

package/src/api/messaging/changeThreadName.js

@@ -0,0 +1,123 @@
+"use strict";
+
+const utils = require('../../../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets the name of a group chat thread via MQTT.
+   *
+   * @param {string} newName The new name for the group chat.
+   * @param {string} threadID The ID of the group chat thread.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the group name 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 gcname(newName, 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 change the group chat name."));
+    }
+    if (typeof newName !== 'string') {
+      return _callback(new Error("newName must be a string."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      thread_name: newName,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '32',
+      payload: JSON.stringify(queryPayload),
+      queue_name: threadID.toString(),
+      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 gcname: ${err.message || err}`));
+      }
+      
+      const gcnameChangeEvent = {
+        type: "thread_name_update",
+        threadID: threadID,
+        newName: newName,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, gcnameChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/createCommentPost.js

@@ -0,0 +1,207 @@
+'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));
+    
+    if (res.errors) {
+        throw res;
+    }
+    
+    const commentEdge = res.data.comment_create.feedback_comment_edge;
+    return {
+        id: commentEdge.node.id,
+        url: commentEdge.node.feedback.url,
+        count: res.data.comment_create.feedback.total_comment_count
+    };
+}
+
+/**
+ * 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;
+    };
+};