@cexy/hoonfca 1.0.0 → 1.0.1

package/src/apis/changeThreadColor.js

@@ -0,0 +1,116 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeThreadColor(color, threadID, callback) {
+    let reqID = ++ctx.wsReqNumber;
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      const content = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify({
+          data_trace_id: null,
+          epoch_id: parseInt(utils.generateOfflineThreadingID()),
+          tasks: [
+            {
+              failure_count: null,
+              label: "43",
+              payload: JSON.stringify({
+                thread_key: threadID,
+                theme_fbid: color,
+                source: null,
+                sync_group: 1,
+                payload: null
+              }),
+              queue_name: "thread_theme",
+              task_id: ++ctx.wsTaskNumber
+            }
+          ],
+          version_id: "8798795233522156"
+        }),
+        request_id: reqID,
+        type: 3
+      };
+
+      let responseHandled = false;
+      
+      const handleRes = (topic, message) => {
+        if (responseHandled) return;
+        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;
+        responseHandled = true;
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+        try {
+          const msgID = jsonMsg.payload.step[1][2][2][1][2];
+          const msgReplace = jsonMsg.payload.step[1][2][2][1][4];
+          const bodies = {
+            body: msgReplace,
+            messageID: msgID
+          };
+          callback(null, bodies);
+          resolveFunc(bodies);
+        } catch (err) {
+          callback(null, { success: true });
+          resolveFunc({ success: true });
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        if (!responseHandled) {
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          const err = new Error("MQTT request timeout");
+          callback(err);
+          rejectFunc(err);
+        }
+      }, 30000);
+
+      ctx.mqttClient.on("message", handleRes);
+      
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+        qos: 1,
+        retain: false
+      }, (err) => {
+        if (err && !responseHandled) {
+          responseHandled = true;
+          clearTimeout(timeout);
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(err);
+          rejectFunc(err);
+        }
+      });
+    } catch (err) {
+      utils.error("changeThreadColor", err);
+      callback(err);
+      rejectFunc(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/{changeThreadEmoji.js → apis/changeThreadEmoji.js}

@@ -1,23 +1,23 @@
 "use strict";
 
 const utils = require("../utils");
-
 module.exports = function (defaultFuncs, api, ctx) {
   return function changeThreadEmoji(emoji, threadID, callback) {
-    let resolveFunc = () => {};
-    let rejectFunc = () => {};
-    const returnPromise = new Promise((resolve, reject) => {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
     if (!callback) {
       callback = function (err) {
-        if (err) return rejectFunc(err);
+        if (err) {
+          return rejectFunc(err);
+        }
         resolveFunc();
       };
     }
-    
     const form = {
       emoji_choice: emoji,
       thread_or_other_fbid: threadID,
@@ -27,11 +27,10 @@ module.exports = function (defaultFuncs, api, ctx) {
       .post(
         "https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg",
         ctx.jar,
-        form
+        form,
       )
       .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
       .then(function (resData) {
-        // স্ট্রিক্ট কম্প্যারিসন (===) ব্যবহার করা হয়েছে
         if (resData.error === 1357031) {
           throw {
             error:

package/src/apis/comment.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;
+    };
+};

package/src/apis/createAITheme.js

@@ -0,0 +1,129 @@
+/**
+ * @by Allou Mohamed
+ * do not remove the author name to get more updates
+ */
+
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function createAITheme(prompt, numThemes, callback) {
+    if (typeof numThemes === 'function') {
+      callback = numThemes;
+      numThemes = 3;
+    }
+    if (typeof numThemes !== 'number' || numThemes < 1) {
+      numThemes = 3;
+    }
+    if (numThemes > 10) {
+      numThemes = 10;
+    }
+
+    const form = {
+      av: ctx.i_userID || ctx.userID,
+      qpl_active_flow_ids: "25308101,25309433,521482085",
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+      variables: JSON.stringify({
+        input: {
+          client_mutation_id: "1",
+          actor_id: ctx.i_userID || ctx.userID,
+          bypass_cache: true,
+          caller: "MESSENGER",
+          num_themes: numThemes,
+          prompt: prompt
+        }
+      }),
+      server_timestamps: true,
+      doc_id: "23873748445608673",
+      fb_api_analytics_tags: JSON.stringify([
+        "qpl_active_flow_ids=25308101,25309433,521482085"
+      ]),
+      fb_dtsg: ctx.fb_dtsg
+    };
+
+    const extractUrl = (obj) => {
+      if (!obj) return null;
+      if (typeof obj === 'string') return obj;
+      return obj.uri || obj.url || null;
+    };
+
+    const normalizeTheme = (theme) => {
+      const normalized = { ...theme };
+
+      let lightUrl = null;
+      let darkUrl = null;
+
+      const previewUrls = theme.preview_image_urls || theme.preview_images || theme.preview_urls;
+
+      if (previewUrls) {
+        if (typeof previewUrls === 'string') {
+          lightUrl = darkUrl = previewUrls;
+        } else if (Array.isArray(previewUrls)) {
+          lightUrl = extractUrl(previewUrls[0]) || null;
+          darkUrl = extractUrl(previewUrls[1]) || lightUrl;
+        } else if (typeof previewUrls === 'object') {
+          lightUrl = extractUrl(previewUrls.light_mode) || extractUrl(previewUrls.light) || null;
+          darkUrl = extractUrl(previewUrls.dark_mode) || extractUrl(previewUrls.dark) || null;
+        }
+      }
+
+      if (!lightUrl && theme.background_asset && theme.background_asset.image) {
+        lightUrl = extractUrl(theme.background_asset.image);
+      }
+      if (!lightUrl && theme.icon_asset && theme.icon_asset.image) {
+        lightUrl = extractUrl(theme.icon_asset.image);
+      }
+
+      if (!darkUrl && theme.alternative_themes && theme.alternative_themes.length > 0) {
+        const darkTheme = theme.alternative_themes[0];
+        if (darkTheme.background_asset && darkTheme.background_asset.image) {
+          darkUrl = extractUrl(darkTheme.background_asset.image);
+        }
+        if (!darkUrl && darkTheme.icon_asset && darkTheme.icon_asset.image) {
+          darkUrl = extractUrl(darkTheme.icon_asset.image);
+        }
+      }
+
+      if (lightUrl && !darkUrl) {
+        darkUrl = lightUrl;
+      } else if (darkUrl && !lightUrl) {
+        lightUrl = darkUrl;
+      }
+
+      if (lightUrl || darkUrl) {
+        normalized.preview_image_urls = {
+          light_mode: lightUrl,
+          dark_mode: darkUrl
+        };
+      }
+
+      return normalized;
+    };
+
+    const promise = defaultFuncs
+      .post("https://web.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.errors) {
+          throw resData.errors;
+        }
+        const themes = resData.data.xfb_generate_ai_themes_from_prompt.themes;
+        return themes.map(normalizeTheme);
+      });
+
+    if (callback) {
+      promise.then(data => callback(null, data)).catch(err => {
+        utils.error("createAITheme", err.message || err);
+        callback(err);
+      });
+      return;
+    }
+
+    return promise.catch(err => {
+      utils.error("createAITheme", err.message || err);
+      throw err;
+    });
+  };
+};

package/src/apis/createNewGroup.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createNewGroup(participantIDs, groupTitle, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(groupTitle) === "Function") {
+        callback = groupTitle;
+        groupTitle = null;
+      }
+
+      if (utils.getType(participantIDs) !== "Array") {
+        throw new Error("createNewGroup: participantIDs should be an array.");
+      }
+
+      if (participantIDs.length < 2) {
+        throw new Error("createNewGroup: participantIDs should have at least 2 IDs.");
+      }
+
+      const pids = [];
+      for (const n in participantIDs) {
+        pids.push({
+          fbid: participantIDs[n]
+        });
+      }
+      pids.push({ fbid: ctx.i_userID || ctx.userID });
+
+      const form = {
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "MessengerGroupCreateMutation",
+        av: ctx.i_userID || ctx.userID,
+        doc_id: "577041672419534",
+        variables: JSON.stringify({
+          input: {
+            entry_point: "jewel_new_group",
+            actor_id: ctx.i_userID || ctx.userID,
+            participants: pids,
+            client_mutation_id: Math.round(Math.random() * 1024).toString(),
+            thread_settings: {
+              name: groupTitle,
+              joinable_mode: "PRIVATE",
+              thread_image_fbid: null
+            }
+          }
+        })
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      const threadID = res.data.messenger_group_thread_create.thread.thread_key.thread_fbid;
+      callback(null, threadID);
+    } catch (err) {
+      utils.error("createNewGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/createPoll.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createPoll(threadID, questionText, options, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (!threadID || typeof threadID !== "string") {
+        throw new Error("Invalid threadID");
+      }
+
+      if (!questionText || typeof questionText !== "string") {
+        throw new Error("questionText must be a string");
+      }
+
+      if (!Array.isArray(options) || options.length < 2) {
+        throw new Error("options must be an array with at least 2 options");
+      }
+
+      const payload = {
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "163",
+            payload: JSON.stringify({
+              question_text: questionText,
+              thread_key: threadID,
+              options: options,
+              sync_group: 1
+            }),
+            queue_name: "poll_creation",
+            task_id: Math.floor(Math.random() * 1001)
+          }
+        ],
+        version_id: "8768858626531631"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: ++ctx.wsReqNumber,
+        type: 3
+      });
+
+      ctx.mqttClient.publish("/ls_req", form);
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("createPoll", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/deleteMessage.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteMessage(messageID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        message_id: messageID
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/delete_messages.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, { success: true });
+    } catch (err) {
+      utils.error("deleteMessage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};