shadowx-fca 8.0.0

package/src/sendBroadcast.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var logger = require("../logger");
+
+/**
+ * sendBroadcast — Send a message to multiple threads in parallel
+ * with rate limiting and per-thread delivery tracking.
+ *
+ * Usage:
+ *   api.sendBroadcast(msg, threadIDs, [options], [callback])
+ *
+ * Options:
+ *   delay    {number}  ms between each send (default: 1000)
+ *   parallel {number}  max concurrent sends (default: 3)
+ *   onEach   {function(err, result, threadID)} called after each individual send
+ *
+ * Returns:
+ *   Promise<{ sent: string[], failed: { id, error }[], total: number }>
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendBroadcast(msg, threadIDs, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = {};
+        }
+        options = options || {};
+
+        var delay     = typeof options.delay    === "number" ? options.delay    : 1000;
+        var parallel  = typeof options.parallel === "number" ? options.parallel : 3;
+        var onEach    = typeof options.onEach   === "function" ? options.onEach : null;
+
+        if (!Array.isArray(threadIDs) || threadIDs.length === 0) {
+            var err = new Error("sendBroadcast: threadIDs must be a non-empty array.");
+            if (typeof callback === "function") return callback(err);
+            return Promise.reject(err);
+        }
+
+        var sent   = [];
+        var failed = [];
+        var ids    = threadIDs.slice();
+
+        logger.info("Broadcast", "Sending to " + ids.length + " threads [parallel=" + parallel + " delay=" + delay + "ms]");
+
+        function sleep(ms) {
+            return new Promise(function (res) { setTimeout(res, ms); });
+        }
+
+        async function sendOne(id) {
+            try {
+                var info = await api.sendMessage(msg, String(id));
+                sent.push(String(id));
+                if (onEach) onEach(null, info, id);
+                logger.success("Broadcast", "→ " + id + " [" + sent.length + "/" + ids.length + "]");
+            } catch (e) {
+                failed.push({ id: String(id), error: e.message || String(e) });
+                if (onEach) onEach(e, null, id);
+                logger.warn("Broadcast", "✘ " + id + ": " + (e.message || e));
+            }
+        }
+
+        var promise = (async function () {
+            var i = 0;
+            while (i < ids.length) {
+                var batch = ids.slice(i, i + parallel);
+                var tasks = batch.map(function (id, idx) {
+                    return sleep(idx * delay).then(function () { return sendOne(id); });
+                });
+                await Promise.all(tasks);
+                i += parallel;
+                if (i < ids.length) await sleep(delay);
+            }
+
+            var result = {
+                sent:   sent,
+                failed: failed,
+                total:  ids.length
+            };
+
+            logger.success(
+                "Broadcast",
+                "Done — " + sent.length + " sent, " + failed.length + " failed out of " + ids.length
+            );
+
+            return result;
+        })();
+
+        if (typeof callback === "function") {
+            promise.then(function (r) { callback(null, r); }).catch(function (e) { callback(e); });
+        }
+
+        return promise;
+    };
+};

package/src/sendButtons.js

@@ -0,0 +1,161 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require('../utils');
+
+function safeParseInt(value, fallback = 0) {
+  const parsed = parseInt(value);
+  return isNaN(parsed) ? fallback : parsed;
+}
+
+const SHUFFLE_SEED = 42;
+
+function generateShufflePattern(length) {
+  const pattern = Array.from({ length }, (_, i) => i);
+  let seed = SHUFFLE_SEED;
+  for (let i = length - 1; i > 0; i--) {
+    seed = (seed * 9301 + 49297) % 233280;
+    const j = Math.floor((seed / 233280) * (i + 1));
+    [pattern[i], pattern[j]] = [pattern[j], pattern[i]];
+  }
+  return pattern;
+}
+
+function generateReversePattern(shufflePattern) {
+  const reversePattern = new Array(shufflePattern.length);
+  for (let i = 0; i < shufflePattern.length; i++) {
+    reversePattern[shufflePattern[i]] = i;
+  }
+  return reversePattern;
+}
+
+function unrearrange(rearrangedId) {
+  try {
+    if (!rearrangedId || typeof rearrangedId !== "string") {
+      console.error("Unrearrange: Invalid input");
+      return null;
+    }
+    const pattern = generateShufflePattern(rearrangedId.length);
+    const reversePattern = generateReversePattern(pattern);
+    const original = new Array(rearrangedId.length);
+    for (let i = 0; i < rearrangedId.length; i++) {
+      original[reversePattern[i]] = rearrangedId[i];
+    }
+    return original.join("");
+  } catch (err) {
+    console.error("Unrearrange error:", err.message);
+    return null;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function sendButtons(
+    call_to_actions,
+    text,
+    threadID,
+    messageID,
+    callback,
+  ) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    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) {
+      const err = new Error("Not connected to MQTT");
+      callback(err);
+      return returnPromise;
+    }
+
+    if (!ctx.reqCallbacks) ctx.reqCallbacks = {};
+    if (!ctx.callback_Task) ctx.callback_Task = {};
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const reqID = ctx.wsReqNumber;
+    const cta_id = unrearrange(call_to_actions);
+    
+    if (!cta_id) {
+      const err = new Error("Failed to unrearrange messageID");
+      callback(err);
+      return returnPromise;
+    }
+
+    const taskPayload = {
+      thread_id: threadID,
+      otid: safeParseInt(generateOfflineThreadingID()),
+      source: 65544,
+      send_type: 5,
+      sync_group: 1,
+      forwarded_msg_id: cta_id,
+      strip_forwarded_msg_caption: 1,
+      skip_url_preview_gen: 0,
+      text: text || "",
+      initiating_source: 1,
+    };
+
+    if (messageID != undefined && messageID != null) {
+      taskPayload.reply_metadata = {
+        reply_source_id: messageID,
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+
+    const task = {
+      failure_count: null,
+      label: "46",
+      payload: JSON.stringify(taskPayload),
+      queue_name: `${threadID}`,
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: safeParseInt(generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: "24180904141611263",
+      }),
+      request_id: reqID,
+      type: 3,
+    };
+
+    // Setup the callback listener
+    ctx.callback_Task[reqID] = {
+      type: "call_to_actions",
+      callback: function (err, data) {
+        if (err) return callback(err);
+
+        const messageID =
+          JSON.parse(data)?.step?.[1]?.[2]?.[2]?.[1]?.[3] || null;
+
+        const result = {
+          messageID: cta_id,
+          senderID: ctx.userID,
+          threadID: threadID,
+          action: "cta_buttons",
+        };
+
+        callback(null, result);
+      },
+    };
+
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+      qos: 1,
+      retain: false,
+    });
+
+    return returnPromise;
+  };
+};

package/src/sendComment.js

@@ -0,0 +1,159 @@
+"use strict";
+//added by jonell Magallanes hshs
+var utils = require("../utils");
+var log = require("npmlog");
+var bluebird = require("bluebird");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function getGUID() {
+    let _0x161e32 = Date.now(),
+      _0x4ec135 = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
+        /[xy]/g,
+        function (_0x32f946) {
+          let _0x141041 = Math.floor((_0x161e32 + Math.random() * 16) % 16);
+          _0x161e32 = Math.floor(_0x161e32 / 16);
+          let _0x31fcdd = (
+            _0x32f946 == "x" ? _0x141041 : (_0x141041 & 0x3) | 0x8
+          ).toString(16);
+          return _0x31fcdd;
+        },
+      );
+    return _0x4ec135;
+  }
+
+  function uploadAttachment(attachment, callback) {
+    var uploads = [];
+
+    // create an array of promises
+    if (!utils.isReadableStream(attachment)) {
+      throw {
+        error:
+          "Attachment should be a readable stream and not " +
+          utils.getType(attachment) +
+          ".",
+      };
+    }
+
+    var form = {
+      file: attachment,
+      av: api.getCurrentUserID(),
+      profile_id: api.getCurrentUserID(),
+      source: "19",
+      target_id: api.getCurrentUserID(),
+      __user: api.getCurrentUserID(),
+      __a: "1",
+    };
+
+    uploads.push(
+      defaultFuncs
+        .postFormData(
+          "https://www.facebook.com/ajax/ufi/upload",
+          ctx.jar,
+          form,
+          {},
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) {
+            throw resData;
+          }
+          return resData.payload;
+        }),
+    );
+
+    // resolve all promises
+    bluebird
+      .all(uploads)
+      .then(function (resData) {
+        callback(null, resData);
+      })
+      .catch(function (err) {
+        log.error("uploadAttachment", err);
+        return callback(err);
+      });
+  }
+
+  async function sendCommentToFb(postId, text, fileID) {
+    const feedback_id = Buffer.from("feedback:" + postId).toString("base64");
+
+    const ss1 = getGUID();
+    const ss2 = getGUID();
+
+    const form = {
+      av: api.getCurrentUserID(),
+      fb_api_req_friendly_name: "CometUFICreateCommentMutation",
+      fb_api_caller_class: "RelayModern",
+      doc_id: "4744517358977326",
+      variables: JSON.stringify({
+        displayCommentsFeedbackContext: null,
+        displayCommentsContextEnableComment: null,
+        displayCommentsContextIsAdPreview: null,
+        displayCommentsContextIsAggregatedShare: null,
+        displayCommentsContextIsStorySet: null,
+        feedLocation: "TIMELINE",
+        feedbackSource: 0,
+        focusCommentID: null,
+        includeNestedComments: false,
+        input: {
+          attachments: fileID ? [{ media: { id: fileID } }] : null,
+          feedback_id: feedback_id,
+          formatting_style: null,
+          message: {
+            ranges: [],
+            text: text,
+          },
+          is_tracking_encrypted: true,
+          tracking: [],
+          feedback_source: "PROFILE",
+          idempotence_token: "client:" + ss1,
+          session_id: ss2,
+          actor_id: api.getCurrentUserID(),
+          client_mutation_id: Math.round(Math.random() * 19),
+        },
+        scale: 3,
+        useDefaultActor: false,
+        UFI2CommentsProvider_commentsKey: "ProfileCometTimelineRoute",
+      }),
+    };
+
+    const res = JSON.parse(
+      await api.httpPost("https://www.facebook.com/api/graphql/", form),
+    );
+    return res;
+  }
+
+  return async function sendComment(content, postId, callback) {
+    if (typeof content === "object") {
+      var text = content.body || "";
+      if (content.attachment) {
+        if (!utils.isReadableStream(content.attachment)) {
+          throw new Error("Attachment must be a ReadableStream");
+        }
+
+        uploadAttachment(content.attachment, async function (err, files) {
+          if (err) {
+            return callback(err);
+          }
+
+          await sendCommentToFb(postId, text, files[0].fbid)
+            .then((res) => {
+              return callback(null, res);
+            })
+            .catch((err) => {
+              return callback(err);
+            });
+        });
+      }
+    } else if (typeof content === "string") {
+      var text = content;
+      await sendCommentToFb(postId, text, null)
+        .then((res) => {
+          return callback(null, res);
+        })
+        .catch((_) => {
+          return;
+        });
+    } else throw new Error("Invalid content");
+  };
+};
+// example usage

package/src/sendEmoji.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendEmoji(emoji, emojiSize, threadID, callback) {
+        if (typeof emojiSize === "string" && !["small","medium","large"].includes(emojiSize)) {
+            callback = threadID; threadID = emojiSize; emojiSize = "medium";
+        }
+        if (typeof emojiSize === "function") { callback = emojiSize; emojiSize = "medium"; threadID = emoji; }
+        return api.sendMessage({ emoji, emojiSize: emojiSize || "medium" }, threadID, callback);
+    };
+};

package/src/sendFile.js

@@ -0,0 +1,9 @@
+"use strict";
+var fs = require("fs");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendFile(filePath, threadID, caption, callback) {
+        if (typeof caption === "function") { callback = caption; caption = ""; }
+        var stream = typeof filePath === "string" ? fs.createReadStream(filePath) : filePath;
+        return api.sendMessage({ attachment: stream, body: caption || "" }, threadID, callback);
+    };
+};

package/src/sendFriendRequest.js

@@ -0,0 +1,33 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendFriendRequest(userID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_caller_class: "RelayModern",
+            fb_api_req_friendly_name: "FriendingCometFriendRequestSendMutation",
+            variables: JSON.stringify({
+                input: {
+                    click_correlation_id: String(Date.now()),
+                    click_proof_validation_result: '{"validated":true}',
+                    friend_requestee_ids: [String(userID)],
+                    friending_channel: "FRIENDS_HOME_MAIN",
+                    warn_ack_for_ids: [],
+                    actor_id: ctx.userID,
+                    client_mutation_id: String(Math.floor(Math.random() * 10))
+                },
+                scale: 1
+            }),
+            server_timestamps: true,
+            doc_id: "24614631718227645"
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var result = resData.data && resData.data.friend_request_send;
+                cb(null, result || true);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/sendGif.js

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

package/src/sendImage.js

@@ -0,0 +1,9 @@
+"use strict";
+var fs = require("fs");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendImage(imagePath, threadID, caption, callback) {
+        if (typeof caption === "function") { callback = caption; caption = ""; }
+        var stream = typeof imagePath === "string" ? fs.createReadStream(imagePath) : imagePath;
+        return api.sendMessage({ attachment: stream, body: caption || "" }, threadID, callback);
+    };
+};

package/src/sendLocation.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = function (defaultFuncs, api, ctx) {
+    return function sendLocation(latitude, longitude, threadID, isCurrentLocation, callback) {
+        if (typeof isCurrentLocation === "function") { callback = isCurrentLocation; isCurrentLocation = true; }
+        return api.sendMessage({
+            location: { latitude, longitude, current: isCurrentLocation !== false }
+        }, threadID, callback);
+    };
+};