@cexy/hoonfca 1.0.0

package/src/setProfileGuard.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return (guard, callback) => {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    if (utils.getType(guard) !== "Boolean") {
+      return callback({
+        error: "Please pass a boolean as a second argument.",
+      });
+    }
+
+    const uid = ctx.userID;
+    const form = {
+      av: uid,
+      variables: JSON.stringify({
+        input: {
+          is_shielded: guard ? true : false,
+          actor_id: uid,
+          client_mutation_id: "1"
+        },
+        scale: 1
+      }),
+      doc_id: "1477043292367183",
+      fb_api_req_friendly_name: "IsShieldedSetMutation",
+      fb_api_caller_class: "IsShieldedSetMutation"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (!resData) {
+          throw { error: "setProfileGuard returned empty response." };
+        }
+        if (resData.err || resData.errors || resData.error) {
+          throw {
+            error: resData.err || resData.errors || resData.error
+          };
+        }
+        return callback(null, resData);
+      })
+      .catch(err => {
+        utils.error("setProfileGuard", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/setStoryReaction.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const utils = require('../utils.js');
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function setStoryReaction(storyID, react, callback) {
+    var cb;
+    var returnPromise = new Promise(function(resolve, reject) {
+      cb = error => error ? reject(error) : resolve();
+    });
+
+    if (typeof react == 'function') {
+      callback = react;
+      react = 1;
+    }
+    if (typeof callback == 'function') {
+      cb = callback;
+    }
+
+    if (!storyID) {
+      return cb({ error: 'setStoryReaction: storyID is required.' });
+    }
+
+    // সাপোর্ট করা রিঅ্যাকশন ও তাদের টেক্সট ফরম্যাট ম্যাপিং
+    var map = {
+      1: '👍',
+      2: '❤️',
+      3: '🤗',
+      4: '😆',
+      5: '😮',
+      6: '😢',
+      7: '😡'
+    };
+
+    var aliasMap = {
+      'like': 1, 'thumbsup': 1, '👍': 1,
+      'heart': 2, 'love': 2, '❤️': 2,
+      'care': 3, 'hug': 3, '🤗': 3,
+      'haha': 4, 'laugh': 4, '😆': 4,
+      'wow': 5, 'shock': 5, '😮': 5,
+      'sad': 6, 'cry': 6, '😢': 6,
+      'angry': 7, 'rage': 7, '😡': 7
+    };
+
+    // রিঅ্যাকশন ইনপুট পার্স করা
+    var targetReact = 1;
+    if (react !== undefined && react !== null) {
+      var reactStr = String(react).toLowerCase().trim();
+      if (aliasMap[reactStr] !== undefined) {
+        targetReact = aliasMap[reactStr];
+      } else {
+        var reactNum = Number(react);
+        if (!isNaN(reactNum) && map[reactNum] !== undefined) {
+          targetReact = reactNum;
+        }
+      }
+    }
+
+    var form = {
+      fb_api_req_friendly_name: 'useStoriesSendReplyMutation',
+      variables: JSON.stringify({
+        input: {
+          attribution_id_v2: `StoriesCometSuspenseRoot.react,comet.stories.viewer,unexpected,${Date.now()},538296,,;CometHomeRoot.react,comet.home,via_cold_start,${Date.now()},850302,4748854339,`,
+          lightweight_reaction_actions: {
+            offsets: [0],
+            reaction: map[targetReact]
+          },
+          message: map[targetReact],
+          story_id: storyID.toString(),
+          story_reply_type: "LIGHT_WEIGHT",
+          actor_id: ctx.userID,
+          client_mutation_id: String(parseInt(Math.random() * 16))
+        }
+      }),
+      doc_id: '4826141330837571'
+    };
+
+    defaultFuncs
+      .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(res) {
+        if (!res) {
+          throw { error: "setStoryReaction returned empty response." };
+        }
+        if (res.errors) {
+          throw res;
+        }
+        return cb();
+      })
+      .catch(function(err) {
+        utils.error('setStoryReaction', err);
+        return cb(err);
+      });
+
+    return returnPromise;
+  }
+}

package/src/setTitle.js

@@ -0,0 +1,100 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setTitle(newTitle, threadID, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (
+        utils.getType(threadID) === "Function" ||
+        utils.getType(threadID) === "AsyncFunction"
+      ) {
+        callback = threadID;
+        threadID = undefined;
+      } else {
+        callback = function (err, data) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc(data);
+        };
+      }
+    }
+
+    if (!threadID) {
+      return callback({ error: "Please pass a threadID as a second argument." });
+    }
+
+    const titleStr = newTitle !== null && newTitle !== undefined ? newTitle.toString() : "";
+    const threadIDStr = threadID.toString();
+    const messageAndOTID = utils.generateOfflineThreadingID();
+
+    const form = {
+      client: "mercury",
+      action_type: "ma-type:log-message",
+      author: "fbid:" + (ctx.userID),
+      author_email: "",
+      coordinates: "",
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      manual_retry_cnt: "0",
+      thread_fbid: threadIDStr,
+      thread_name: titleStr,
+      thread_id: threadIDStr,
+      log_message_type: "log:thread-name",
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/set_thread_name/",
+        ctx.jar,
+        form,
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (!resData) {
+          throw { error: "setTitle returned empty response." };
+        }
+
+        if (resData.error && resData.error === 1545012) {
+          throw { error: "Cannot change chat title: Not member of chat." };
+        }
+
+        if (resData.error && resData.error === 1545003) {
+          throw { error: "Cannot set title of single-user chat." };
+        }
+
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback(null);
+      })
+      .catch(function (err) {
+        utils.error("setTitle", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/shareContact.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function shareContact(text, senderID, threadID, callback) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    if (!ctx.mqttClient) {
+      return callback(new Error('Not connected to MQTT'));
+    }
+
+    if (!senderID || !threadID) {
+      return callback({ error: "senderID and threadID are required." });
+    }
+
+    // safe initialization of request counters
+    if (ctx.wsReqNumber === undefined || ctx.wsReqNumber === null) {
+      ctx.wsReqNumber = 0;
+    }
+    if (ctx.wsTaskNumber === undefined || ctx.wsTaskNumber === null) {
+      ctx.wsTaskNumber = 0;
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      contact_id: senderID.toString(),
+      sync_group: 1,
+      text: text || "",
+      thread_id: threadID.toString()
+    };
+
+    const query = {
+      failure_count: null,
+      label: '359',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'messenger_contact_sharing', // xma_open_contact_share
+      task_id: Math.floor(Math.random() * 1001),
+    };
+
+    const context = {
+      app_id: '2220391788200892',
+      payload: {
+        tasks: [query],
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        version_id: '7214102258676893',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    context.payload = JSON.stringify(context.payload);
+
+    // safe callback mapping to prevent crashes
+    if (typeof callback === 'function') {
+      if (!ctx.callback_Task) {
+        ctx.callback_Task = {};
+      }
+      ctx.callback_Task[ctx.wsReqNumber] = { callback, type: "shareContact" };
+      
+      // also fallback to reqCallbacks if your bot utilizes it
+      if (ctx.reqCallbacks) {
+        ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+      }
+    }
+
+    ctx.mqttClient.publish(
+      '/ls_req', 
+      JSON.stringify(context), 
+      { qos: 1, retain: false },
+      function (err, data) {
+        if (err) {
+          utils.error("shareContact", err);
+          return callback(err);
+        }
+        // If not using callback listeners in state, trigger immediately
+        if (!ctx.callback_Task && !ctx.reqCallbacks) {
+          callback(null, data);
+        }
+      }
+    );
+
+    return returnPromise;
+  };
+};

package/src/shareLink.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return async function shareLink(text, url, threadID, callback) {
+		var resolveFunc = function () {};
+		var rejectFunc = function () {};
+		var returnPromise = new Promise(function (resolve, reject) {
+			resolveFunc = resolve;
+			rejectFunc = reject;
+		});
+
+		if (!callback) {
+			callback = function (err, data) {
+				if (err) return rejectFunc(err);
+				resolveFunc(data);
+			};
+		}
+
+		if (!ctx.mqttClient) {
+			return callback({ error: "Not connected to MQTT" });
+		}
+
+		if (!threadID) {
+			return callback({ error: "ThreadID is required." });
+		}
+
+		if (!url) {
+			return callback({ error: "URL is required." });
+		}
+
+		// safe initialization of request counters
+		if (ctx.req_ID === undefined || ctx.req_ID === null) {
+			ctx.req_ID = 0;
+		}
+		if (!ctx.callback_Task) {
+			ctx.callback_Task = {};
+		}
+
+		const currentReqID = ++ctx.req_ID;
+		const threadIDStr = threadID.toString();
+
+		const payload = {
+			"app_id": "2220391788200892",
+			"payload": JSON.stringify({
+				tasks: [{
+					label: 46,
+					payload: JSON.stringify({
+						"otid": utils.generateOfflineThreadingID(),
+						"source": 524289,
+						"sync_group": 1,
+						"send_type": 6,
+						"mark_thread_read": 0,
+						"url": url,
+						"text": text || "",
+						"thread_id": threadIDStr,
+						"initiating_source": 0
+					}),
+					queue_name: threadIDStr,
+					task_id: Math.floor(Math.random() * 1001),
+					failure_count: null,
+				}],
+				epoch_id: parseInt(utils.generateOfflineThreadingID()),
+				version_id: '7191105584331330',
+			}),
+			"request_id": currentReqID,
+			"type": 3
+		};
+
+		ctx.callback_Task[currentReqID] = {
+			callback,
+			type: "shareLink"
+		};
+
+		// fallback trigger to reqCallbacks if used by the library
+		if (ctx.reqCallbacks) {
+			ctx.reqCallbacks[currentReqID] = callback;
+		}
+
+		ctx.mqttClient.publish(
+			'/ls_req',
+			JSON.stringify(payload),
+			{
+				qos: 1,
+				retain: false,
+			},
+			function (err, data) {
+				if (err) {
+					utils.error("shareLink", err);
+					// clean up callback store on error
+					delete ctx.callback_Task[currentReqID];
+					if (ctx.reqCallbacks) delete ctx.reqCallbacks[currentReqID];
+					return callback(err);
+				}
+				// if there is no global listener, execute immediately on success
+				if (!ctx.reqCallbacks && ctx.callback_Task[currentReqID]) {
+					callback(null, data);
+				}
+			}
+		);
+
+		return returnPromise;
+	};
+};

package/src/stopListenMqtt.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function stopListenMqtt(callback) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    if (!ctx.mqttClient) {
+      return callback(new Error("Not connected to MQTT"));
+    }
+
+    utils.log("stopListenMqtt", "Stopping...");
+
+    try {
+      ctx.mqttClient.unsubscribe("/webrtc");
+      ctx.mqttClient.unsubscribe("/rtc_multi");
+      ctx.mqttClient.unsubscribe("/onevc");
+      ctx.mqttClient.publish("/browser_close", "{}");
+      
+      ctx.mqttClient.end(false, function (...data) {
+        utils.log("stopListenMqtt", "Stopped");
+        ctx.mqttClient = null;
+        return callback(null, data);
+      });
+    } catch (err) {
+      utils.error("stopListenMqtt", err);
+      return callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/threadColors.js

@@ -0,0 +1,119 @@
+"use strict";
+
+module.exports = function (_defaultFuncs, _api, _ctx) {
+  const themes = {
+    // #region Backward compatibility mapping
+    MessengerBlue: "196241301102133", // DefaultBlue
+    Viking: "1928399724138152", // TealBlue
+    GoldenPoppy: "174636906462322", // Yellow
+    RadicalRed: "2129984390566328", // Red
+    Shocking: "2058653964378557", // LavenderPurple
+    FreeSpeechGreen: "2136751179887052", // Green
+    Pumpkin: "175615189761153", // Orange
+    LightCoral: "980963458735625", // CoralPink
+    MediumSlateBlue: "234137870477637", // BrightPurple
+    DeepSkyBlue: "2442142322678320", // AquaBlue
+    BrilliantRose: "169463077092846", // HotPink
+    // #endregion
+
+    DefaultBlue: "196241301102133",
+    HotPink: "169463077092846",
+    AquaBlue: "2442142322678320",
+    BrightPurple: "234137870477637",
+    CoralPink: "980963458735625",
+    Orange: "175615189761153",
+    Green: "2136751179887052",
+    LavenderPurple: "2058653964378557",
+    Red: "2129984390566328",
+    Yellow: "174636906462322",
+    TealBlue: "1928399724138152",
+    Aqua: "417639218648241",
+    Mango: "930060997172551",
+    Berry: "164535220883264",
+    Citrus: "370940413392601",
+    Candy: "205488546921017",
+
+    Earth: "1833559466821043",
+    Support: "365557122117011",
+    Music: "339021464972092",
+    Pride: "1652456634878319",
+    DoctorStrange: "538280997628317",
+    LoFi: "1060619084701625",
+    Sky: "3190514984517598",
+    LunarNewYear: "357833546030778",
+    Celebration: "627144732056021",
+    Chill: "390127158985345",
+    StrangerThings: "1059859811490132",
+    Dune: "1455149831518874",
+    Care: "275041734441112",
+    Astrology: "3082966625307060",
+    JBalvin: "184305226956268",
+    Birthday: "621630955405500",
+    Cottagecore: "539927563794799",
+    Ocean: "736591620215564",
+    Love: "741311439775765",
+    TieDye: "230032715012014",
+    Monochrome: "788274591712841",
+    Default: "3259963564026002",
+    Rocket: "582065306070020",
+    Berry2: "724096885023603",
+    Candy2: "624266884847972",
+    Unicorn: "273728810607574",
+    Tropical: "262191918210707",
+    Maple: "2533652183614000",
+    Sushi: "909695489504566",
+    Citrus2: "557344741607350",
+    Lollipop: "280333826736184",
+    Shadow: "271607034185782",
+    Rose: "1257453361255152",
+    Lavender: "571193503540759",
+    Tulip: "2873642949430623",
+    Classic: "3273938616164733",
+    Peach: "3022526817824329",
+    Honey: "672058580051520",
+    Kiwi: "3151463484918004",
+    Grape: "193497045377796",
+
+    NonBinary: "737761000603635",
+
+    ThankfulForFriends: "1318983195536293",
+    Transgender: "504518465021637",
+    TaylorSwift: "769129927636836",
+    NationalComingOutDay: "788102625833584",
+    Autumn: "822549609168155",
+    Cyberpunk2077: "780962576430091",
+
+    MothersDay: "1288506208402340",
+    APAHM: "121771470870245",
+    Parenthood: "810978360551741",
+    StarWars: "1438011086532622",
+    GuardianOfTheGalaxy: "101275642962533",
+    Bloom: "158263147151440",
+    BubbleTea: "195296273246380",
+    Basketball: "6026716157422736",
+    ElephantsAndFlowers: "693996545771691"
+  };
+
+  // কেস-ইনসেনসিটিভ সার্চ বা ফলব্যাকের সুবিধাসহ অবজেক্টটি রিটার্ন করা হচ্ছে
+  const themeMap = { ...themes };
+
+  // ডাইনামিকালি আইডি বের করার একটি হেল্পার মেথড
+  themeMap.getThemeID = function (name) {
+    if (!name) return themes.DefaultBlue;
+    const searchName = name.toString().toLowerCase().replace(/\s+/g, "");
+    
+    // থিমের অবজেক্ট থেকে মিলিয়ে দেখা হচ্ছে
+    for (const key of Object.keys(themes)) {
+      if (key.toLowerCase() === searchName) {
+        return themes[key];
+      }
+    }
+    // যদি আইডি সরাসরি পাস করা হয়, সেটিই ফেরত যাবে
+    if (/^\d+$/.test(name)) {
+      return name.toString();
+    }
+    return themes.DefaultBlue;
+  };
+
+  return themeMap;
+};

package/src/unfriend.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function unFriend(userID, callback) {
+    var resolveFunc = function(){};
+    var rejectFunc = function(){};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+    }
+
+    if (!userID) {
+      return callback({ error: "unFriend: userID is required." });
+    }
+
+    var form = {
+      uid: userID.toString(),
+      unref: "bd_friends_tab",
+      floc: "friends_tab",
+      "nctr[_mod]": "pagelet_timeline_app_collection_" + ctx.userID + ":2356318349:2"
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/profile/removefriendconfirm.php",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (!resData) {
+          throw { error: "unFriend returned empty response." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback(null, resData);
+      })
+      .catch(function(err) {
+        utils.error("unFriend", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};