stfca 1.0.25 → 1.0.26

package/index.js

@@ -6,6 +6,7 @@ var log = require("npmlog");
 var { checkForFCAUpdate } = require("./checkUpdate");
 const fs = require('fs');
 const path = require('path');
+const request = require('request');
 /*var { getThemeColors } = require("../../func/utils/log.js");
 var logger = require("../../func/utils/log.js");
 var { cra, cv, cb, co } = getThemeColors();*/
@@ -279,6 +280,51 @@ function buildAPI(globalOptions, html, jar) {
     api.postFormData = function (url, body) {
         return defaultFuncs.postFormData(url, ctx.jar, body);
     };
+
+    const IMGBB_API_KEY = process.env.IMG_BB_KEY || '3e198e6ffe205d1c7968a92fd92177c9';
+    async function uploadImageToImgbb(image, expiration = 600) {
+        const formData = {};
+        if (Buffer.isBuffer(image)) {
+            formData.image = image.toString('base64');
+        } else if (typeof image === 'string') {
+            const dataUriMatch = image.match(/^data:image\/[a-zA-Z]+;base64,(.+)$/);
+            if (dataUriMatch) {
+                formData.image = dataUriMatch[1];
+            } else {
+                formData.image = image.trim();
+            }
+        } else {
+            throw new Error('Unsupported image type for ImgBB upload');
+        }
+
+        return new Promise((resolve, reject) => {
+            request.post(
+                {
+                    url: 'https://api.imgbb.com/1/upload',
+                    qs: {
+                        expiration: expiration,
+                        key: IMGBB_API_KEY
+                    },
+                    formData: formData,
+                    timeout: 60000
+                },
+                function (error, response, body) {
+                    if (error) return reject(error);
+                    try {
+                        const data = JSON.parse(body);
+                        if (!data || !data.success) return reject(data || new Error('ImgBB upload failed'));
+                        resolve(data);
+                    } catch (err) {
+                        reject(err);
+                    }
+                }
+            );
+        });
+    }
+
+    api.uploadImageToImgbb = uploadImageToImgbb;
+    ctx.uploadImageToImgbb = uploadImageToImgbb;
+
     api.getFreshDtsg = async function () {
         try {
             const res = await defaultFuncs.get('https://www.facebook.com/', jar, null, globalOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stfca",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Unofficial Facebook Chat API for Node.js with Auto-Update System - Enhanced by ST | Sheikh Tamim",
   "main": "index.js",
   "files": [
@@ -26,7 +26,27 @@
     "unofficial",
     "fca",
     "st-fca",
-    "sheikh-tamim"
+    "sheikh-tamim",
+    "stfca",
+    "fbchatapi",
+    "fbchat",
+    "messenger-api",
+    "facebook-messenger",
+    "nodejs",
+    "javascript",
+    "auto-update",
+    "update-check",
+    "update-notifier",
+    "version-check",
+    "update-system",
+    "update-manager",
+    "update-handler",
+    "update-service",
+    "update-module",
+    "update-function",
+    "unofficial-facebook-chat-api",
+    "messengerwapper",
+    "e2ee"
   ],
   "author": "ST | Sheikh Tamim",
   "license": "MIT",

package/src/listenMqtt.js

@@ -236,6 +236,15 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
     mqttClient.on('close', function () { });
 }
 
+function attachImgbbUrlToAttachment(api, attachment) {
+    if (!api || !api.uploadImageToImgbb || !attachment || attachment.type !== "photo" || !attachment.url) return;
+    api.uploadImageToImgbb(attachment.url).then((result) => {
+        if (result && result.data) {
+            attachment.imgbbUrl = result.data.url || result.data.display_url || (result.data.image && result.data.image.url);
+        }
+    }).catch(() => { });
+}
+
 function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
     if (v.delta.class == "NewMessage") {
         //Not tested for pages
@@ -257,6 +266,9 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
                     // Store thread type in context for sendMessage to use
                     if (!ctx.threadTypes) ctx.threadTypes = {};
                     ctx.threadTypes[fmtMsg.threadID] = fmtMsg.isSingleUser ? 'dm' : 'group';
+                    if (fmtMsg.attachments && Array.isArray(fmtMsg.attachments)) {
+                        fmtMsg.attachments.forEach(att => attachImgbbUrlToAttachment(api, att));
+                    }
                 } catch (err) {
                     return globalCallback({
                         error: "Problem parsing message object.",
@@ -364,6 +376,9 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
                         timestamp: delta.deltaMessageReply.message.messageMetadata.timestamp,
                         participantIDs: (delta.deltaMessageReply.message.messageMetadata.cid.canonicalParticipantFbids || delta.deltaMessageReply.message.participants || []).map(e => e.toString())
                     };
+                    if (callbackToReturn.attachments && Array.isArray(callbackToReturn.attachments)) {
+                        callbackToReturn.attachments.forEach(att => attachImgbbUrlToAttachment(api, att));
+                    }
 
                     if (delta.deltaMessageReply.repliedToMessage) {
                         //Mention block - #2
@@ -397,6 +412,7 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
                                     x.error = ex;
                                     x.type = "unknown";
                                 }
+                                attachImgbbUrlToAttachment(api, x);
                                 return x;
                             }),
                             args: (delta.deltaMessageReply.repliedToMessage.body || "").trim().split(/\s+/),
@@ -445,6 +461,7 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
                                             x.error = ex;
                                             x.type = "unknown";
                                         }
+                                        attachImgbbUrlToAttachment(api, x);
                                         return x;
                                     }),
                                     args: (fetchData.message.text || "").trim().split(/\s+/) || [],

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/sendMessage.js

@@ -42,6 +42,32 @@ module.exports = (defaultFuncs, api, ctx) => {
 		if (!resData || resData.error || !resData.payload){
 				throw new Error(resData);
 		}
+		return resData.payload;
+	}
+
+	async function ensureImgbbUrl(msg) {
+		if (!api.uploadImageToImgbb) return;
+		try {
+			if (msg.attachment && typeof msg.attachment === 'string') {
+				const uploaded = await api.uploadImageToImgbb(msg.attachment).catch(() => null);
+				if (uploaded && uploaded.data) {
+					msg.url = uploaded.data.url || uploaded.data.display_url || (uploaded.data.image && uploaded.data.image.url);
+					delete msg.attachment;
+				}
+			}
+			if (msg.url && typeof msg.url === 'string') {
+				const dataUri = /^data:image\/[a-zA-Z]+;base64,/.test(msg.url);
+				const base64String = /^[A-Za-z0-9+/=]+$/.test(msg.url.replace(/\s+/g, '')) && msg.url.length > 100;
+				if (dataUri || base64String) {
+					const uploaded = await api.uploadImageToImgbb(msg.url).catch(() => null);
+					if (uploaded && uploaded.data) {
+						msg.url = uploaded.data.url || uploaded.data.display_url || (uploaded.data.image && uploaded.data.image.url);
+					}
+				}
+			}
+		} catch (err) {
+			return;
+		}
 	}
 
 	async function sendContent(form, threadID, isSingleUser, messageAndOTID, callback) {
@@ -122,6 +148,7 @@ module.exports = (defaultFuncs, api, ctx) => {
 		if (msgType === "String") {
 			msg = { body: msg };
 		}
+		await ensureImgbbUrl(msg);
 		
 		// Auto-detect if this is a DM if not explicitly specified
 		if (isSingleUser === null && ctx.threadTypes && ctx.threadTypes[threadID]) {