shadowx-fca 8.0.0

package/src/editMessageOld.js

@@ -0,0 +1,67 @@
+"use_strict";
+
+const { generateOfflineThreadingID } = require('../utils');
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  return function editMessage(text, messageID, callback) {
+
+
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber ??= 0;
+    ctx.wsTaskNumber ??= 0;
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskPayload = {
+      message_id: messageID,
+      text: text,
+    };
+
+    const task = {
+      failure_count: null,
+      label: '742',
+      payload: JSON.stringify(taskPayload),
+      queue_name: 'edit_message',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: {
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [],
+        version_id: '6903494529735864',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    content.payload.tasks.push(task);
+    content.payload = JSON.stringify(content.payload);
+
+    if (isCallable(callback)) {
+      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    }
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+    require(__dirname.replace("/fca-unofficial/src", "/handlers")).modifymsg({
+      body: text,
+      msgId: messageID
+      });
+  };
+}

package/src/enableReactions.js

@@ -0,0 +1,24 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function enableReactions(enable, threadID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "MessengerThreadMessageReactionSettingMutation",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "4752537648194958",
+            variables: JSON.stringify({
+                input: {
+                    actor_id: ctx.userID,
+                    client_mutation_id: String(ctx.clientMutationId++),
+                    thread_key: { thread_fbid: String(threadID) },
+                    message_reactions_setting: enable ? "ALL_REACTIONS" : "NO_REACTIONS"
+                }
+            })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/follow.js

@@ -0,0 +1,74 @@
+"use strict";
+
+/**
+ * Author @YanMaglinte
+ * https://github.com/YANDEVA
+ * 
+ * Example:
+ * api.follow("100090794779367", true); // Set true to follow, false if otherwise.
+ */
+ 
+ //Fixed by Neth
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function follow(senderID, boolean, callback) {
+    /*if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }*/
+    let form;
+    if (boolean) {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserFollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,via_cold_start,1717249218695,723451,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            subscribee_id: senderID,
+            tracking: null,
+            actor_id: ctx.userID,
+            client_mutation_id: "1",
+          },
+          scale: 1,
+        }),
+      };
+    } else {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserUnfollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          action_render_location: "WWW_COMET_FRIEND_MENU",
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,tap_search_bar,1717294006136,602597,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            tracking: null,
+            unsubscribee_id: senderID,
+            actor_id: ctx.userID,
+            client_mutation_id: "10",
+          },
+          scale: 1,
+        }),
+      };
+    }
+
+    api.httpPost("https://www.facebook.com/api/graphql/", form, (err, data) => {
+      if (err) {
+        if (typeof callback === "function") {
+          callback(err);
+        }
+      } else {
+        if (typeof callback === "function") {
+          callback(null, data);
+        }
+      }
+    });
+  };
+};

package/src/followUser.js

@@ -0,0 +1,23 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function followUser(userID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "CometUserFollowMutation",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "5080168885415078",
+            variables: JSON.stringify({
+                input: {
+                    actor_id: ctx.userID,
+                    client_mutation_id: String(ctx.clientMutationId++),
+                    subscribe_to_actor_id: String(userID)
+                }
+            })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/forwardAttachment.js

@@ -0,0 +1,16 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function forwardAttachment(attachmentID, userOrUsers, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        if (!Array.isArray(userOrUsers)) userOrUsers = [userOrUsers];
+        var form = {};
+        userOrUsers.forEach((id, i) => { form["recipient_fbids[" + i + "]"] = id; });
+        form.attachment_id = attachmentID;
+        defaultFuncs.post("https://www.facebook.com/mercury/attachments/forward/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/friendList.js

@@ -0,0 +1,98 @@
+/**
+ * ===========================================================
+ * 🔰 Owner & Developer
+ * -----------------------------------------------------------
+ * 🕊️ Respect the creator & give proper credits if reused.
+ * ===========================================================
+ */
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function friendList(callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      av: ctx.userID,
+      __user: ctx.userID,
+      __a: 1,
+      __req: utils.getSignatureID(),
+      __hs: "20353.HYP:comet_pkg.2.1...0",
+      dpr: 1,
+      __ccg: "EXCELLENT",
+      __rev: "1027407131",
+      __s: utils.getSignatureID(),
+      __hsi: "7552796416884228248",
+      __comet_req: 15,
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.ttstamp,
+      lsd: ctx.fb_dtsg,
+      __spin_r: "1027407131",
+      __spin_b: "trunk",
+      __spin_t: Date.now(),
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "FriendingCometAllFriendsRootQuery",
+      variables: JSON.stringify({ scale: 2 }),
+      server_timestamps: true,
+      doc_id: "24426868700236815"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (!resData || !resData.data) {
+          throw { error: "friendList returned empty object." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+
+        const friendsData = resData.data.viewer?.all_friends?.edges || [];
+        const formattedFriends = friendsData.map(edge => {
+          const friend = edge.node;
+          return {
+            userID: friend.id,
+            name: friend.name,
+            shortName: friend.short_name,
+            gender: friend.gender,
+            profilePicture: friend.profile_picture?.uri || null,
+            profileUrl: friend.url,
+            friendshipStatus: friend.friendship_status,
+            socialContext: friend.social_context?.text || "",
+            isSecureThread: friend.is_secure_thread,
+            subscribeStatus: friend.subscribe_status
+          };
+        });
+
+        const result = {
+          totalCount: resData.data.viewer?.all_friends_data?.count || 0,
+          friendCount: resData.data.viewer?.all_friends_data?.friend_count || 0,
+          friends: formattedFriends
+        };
+
+        callback(null, result);
+      })
+      .catch(function (err) {
+        console.error("friendList", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/getAccess.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var utils = require('../utils');
+var log = require('npmlog');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getAccess(authCode = '', callback) {
+    var cb;
+    var url = 'https://business.facebook.com/';
+    var Referer = url + 'security/twofactor/reauth/?twofac_next=' + encodeURIComponent(url + 'content_management') + '&type=avoid_bypass&app_id=0&save_device=0';
+    var rt = new Promise(function (resolve, reject) {
+      cb = (error, token) => token ? resolve(token) : reject(error);
+    });
+
+    if (typeof authCode == 'function') {
+      callback = authCode;
+      authCode = '';
+    }
+    if (typeof callback == 'function') cb = callback;
+    if (!!ctx.access_token) 
+      cb(null, ctx.access_token);
+    else 
+      utils
+        .get(url + 'content_management', ctx.jar, null, ctx.globalOptions, null, {
+          noRef: true,
+          Origin: url
+        })
+        .then(function (res) {
+          var html = res.body;
+          var lsd = utils.getFrom(html, "[\"LSD\",[],{\"token\":\"", "\"}");
+          return lsd;
+        })
+        .then(function (lsd) {
+          function submitCode(code) {
+            var pCb;
+            var rtPromise = new Promise(function (resolve) {
+              pCb = (error, token) => resolve(cb(error, token));
+            });
+            if (typeof code != 'string')
+              pCb({
+                error: 'submitCode',
+                lerror: 'code must be string',
+                continue: submitCode
+              });
+            else 
+              defaultFuncs
+                .post(url + 'security/twofactor/reauth/enter/', ctx.jar, {
+                  approvals_code: code,
+                  save_device: true,
+                  lsd 
+                }, ctx.globalOptions, null, {
+                  Referer,
+                  Origin: url
+                })
+                .then(function (res) {
+                  var { payload } = JSON.parse(res.body.split(';').pop() || '{}');
+                  if (payload && !payload.codeConfirmed)
+                    throw {
+                      error: 'submitCode',
+                      lerror: payload.message,
+                      continue: submitCode
+                    }
+                  
+                  return;
+                })
+                .then(function () {
+                  return utils
+                    .get(url + 'content_management', ctx.jar, null, ctx.globalOptions, null, { noRef: true })
+                    .then(function (res) {
+                      var html = res.body;
+                      var token = /"accessToken":"(\S+)","clientID":/g.exec(html);
+
+                      return [html, token];
+                    });
+                })
+                .then(function (res) {
+                  if (!res[1]) 
+                    throw {
+                      error: 'token-undefined',
+                      htmlData: res[0]
+                    }
+                  ctx.access_token = res[1][1];                      
+                  return pCb(null, res[1][1]);
+                })
+                .catch(function (err) {
+                  console.error('getAccess', err.error || err);
+                  return pCb(err);
+                });
+    
+            return rtPromise;
+          }
+
+          if (authCode.length == 6 && !isNaN(authCode)) 
+            submitCode(authCode.toString());
+          else if (typeof callback == 'function') 
+            throw {
+              error: 'submitCode',
+              continue: submitCode
+            }
+          else 
+            throw {
+              error: 'authentication code must be string or number or callback must be a function to continue'
+            }
+        })
+        .catch(function (err) {
+          console.error('getAccess', typeof callback == 'function' ? (err.error || err) : err);
+          return cb(err);
+        });
+
+    return rt;
+  }
+}

package/src/getAppState.js

@@ -0,0 +1,13 @@
+"use strict";
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getAppState() {
+        return ctx.jar.getCookies("https://www.facebook.com").map(cookie => ({
+            key: cookie.key,
+            value: cookie.value,
+            domain: cookie.domain,
+            path: cookie.path,
+            httpOnly: cookie.httpOnly,
+            secure: cookie.secure
+        }));
+    };
+};

package/src/getAvatarUser.js

@@ -0,0 +1,11 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getAvatarUser(userID, size, callback) {
+        if (typeof size === "function") { callback = size; size = "large"; }
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var url = "https://graph.facebook.com/" + userID + "/picture?type=" + (size || "large");
+        cb(null, url);
+        return promise;
+    };
+};

package/src/getBio.js

@@ -0,0 +1,24 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getBio(userID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "ProfileAboutSectionQueryRelayQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "5063997373597936",
+            variables: JSON.stringify({ userID: String(userID), sectionToken: "bio" })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var text = resData && resData.data && resData.data.user &&
+                    resData.data.user.introduction_card &&
+                    resData.data.user.introduction_card.text &&
+                    resData.data.user.introduction_card.text.text;
+                cb(null, text || null);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getBotInitialData.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async (callback) => {
+  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);
+      };
+  }
+  utils.log("Fetching account info...");
+  api.httpGet(`https://www.facebook.com/profile.php?id=${ctx.userID}`, null, {
+    customUserAgent: utils.windowsUserAgent
+  }, (err, data) => {
+      if (err) throw err;
+      const profileMatch = data.match(/"CurrentUserInitialData",\[\],\{(.*?)\},(.*?)\]/);
+      if (profileMatch && profileMatch[1]){
+        const accountJson = JSON.parse(`{${profileMatch[1]}}`);
+        accountJson.name = accountJson.NAME;
+        accountJson.uid = accountJson.USER_ID;
+        delete accountJson.NAME;
+        delete accountJson.USER_ID;
+        return callback(null, {
+          ...accountJson
+      });
+      } else return callback(null, { error: "Something went wrong. Maybe its possible that it has a limitation due to spam requests. You can try again later." });
+  }, true);
+  return returnPromise;
+  };
+};
+ 
+ 

package/src/getCtx.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return (str) => ctx[str];
+};

package/src/getCurrentUserID.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getCurrentUserID() {
+        return ctx.userID;
+    };
+};

package/src/getEmojiUrl.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const util = require("util");
+
+module.exports = function () {
+  return function getEmojiUrl(c, size, pixelRatio) {
+    /*
+		 Resolves Facebook Messenger emoji image asset URL for an emoji character.
+		 Supported sizes are 32, 64, and 128.
+		 Supported pixel ratios are '1.0' and '1.5' (possibly more; haven't tested)
+		 */
+    const baseUrl = "https://static.xx.fbcdn.net/images/emoji.php/v8/z%s/%s";
+    pixelRatio = pixelRatio || "1.0";
+
+    const ending = util.format(
+      "%s/%s/%s.png",
+      pixelRatio,
+      size,
+      c.codePointAt(0).toString(16),
+    );
+    let base = 317426846;
+    for (let i = 0; i < ending.length; i++) {
+      base = (base << 5) - base + ending.charCodeAt(i);
+    }
+
+    const hashed = (base & 255).toString(16);
+    return util.format(baseUrl, hashed, ending);
+  };
+};

package/src/getFriendsList.js

@@ -0,0 +1,36 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getFriendsList(callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.postFormData(
+            "https://www.facebook.com/chat/user_info_all",
+            ctx.jar,
+            {},
+            { viewer: ctx.userID }
+        )
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var payload = resData.payload || {};
+                var friends = Object.keys(payload).map(function (id) {
+                    var p = payload[id];
+                    return {
+                        userID: id,
+                        name: p.name,
+                        firstName: p.firstName,
+                        vanity: p.vanity,
+                        thumbSrc: p.thumbSrc,
+                        profileUrl: p.uri,
+                        gender: p.gender,
+                        type: p.type,
+                        isFriend: p.is_friend != null ? !!p.is_friend : true,
+                        isBirthday: !!p.is_birthday
+                    };
+                });
+                cb(null, friends);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getMessage.js

@@ -0,0 +1,37 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getMessage(threadID, messageID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "2848441488556444",
+                    query_params: {
+                        thread_and_message_id: { thread_id: String(threadID), message_id: String(messageID) }
+                    }
+                }
+            })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (!Array.isArray(resData)) throw { error: "Not logged in" };
+                var msg = resData[0] && resData[0].o0 && resData[0].o0.data && resData[0].o0.data.message;
+                if (!msg) throw { error: "Message not found" };
+                cb(null, {
+                    messageID: msg.message_id,
+                    senderID: msg.message_sender && msg.message_sender.id,
+                    body: msg.message && msg.message.text || "",
+                    timestamp: parseInt(msg.timestamp_precise),
+                    threadID: String(threadID),
+                    attachments: (msg.message && msg.message.blob_attachments || []).map(a => {
+                        try { return utils._formatAttachment({ blob_attachment: a }); }
+                        catch (_) { return { type: "unknown" }; }
+                    })
+                });
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getNotes.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getNotes(threadID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "LSNotesFetchQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "27096534960009989",
+            variables: JSON.stringify({ thread_id: String(threadID) })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getOptions.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return (str) => ctx.globalOptions[str];
+};