shadowx-fca 2.4.0 → 2.6.0

package/src/sendMessage2.js

@@ -0,0 +1,243 @@
+"use strict";
+
+const utils = require('../utils');
+// @NethWs3Dev
+
+const allowedProperties = {
+	attachment: true,
+	url: true,
+	sticker: true,
+	emoji: true,
+	emojiSize: true,
+	body: true,
+	mentions: true,
+	location: true,
+};
+
+module.exports = (defaultFuncs, api, ctx) => {
+	async function uploadAttachment(attachments) {
+		var uploads = [];
+		for (var i = 0; i < attachments.length; i++) {
+		 if (!utils.isReadableStream(attachments[i])) {
+				throw new Error("Attachment should be a readable stream and not " + utils.getType(attachments[i]) + ".");
+		 }
+		 const oksir = await defaultFuncs.postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar,{
+			 upload_1024: attachments[i],
+			 voice_clip: "true"
+		 }, {}).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+		 if (oksir.error) {
+			 throw new Error(resData);
+		 }
+		 uploads.push(oksir.payload.metadata[0]);
+		}
+		return uploads;
+	}
+
+	async function getUrl(url) {
+		const resData = await defaultFuncs.post("https://www.facebook.com/message_share_attachment/fromURI/", ctx.jar, {
+			image_height: 960,
+			image_width: 960,
+			uri: url
+		}).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+		if (!resData || resData.error || !resData.payload){
+				throw new Error(resData);
+		}
+	}
+
+	async function sendContent(form, threadID, isSingleUser, messageAndOTID, callback) {
+		// There are three cases here:
+		// 1. threadID is of type array, where we're starting a new group chat with users
+		//    specified in the array.
+		// 2. User is sending a message to a specific user.
+		// 3. No additional form params and the message goes to an existing group chat.
+		if (utils.getType(threadID) === "Array") {
+			for (var i = 0; i < threadID.length; i++) {
+				form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
+			}
+			form["specific_to_list[" + threadID.length + "]"] = "fbid:" + ctx.userID;
+			form["client_thread_id"] = "root:" + messageAndOTID;
+			utils.log("sendMessage", "Sending message to multiple users: " + threadID);
+		} else {
+			const threadIDStr = threadID.toString();
+			// Check if it's a DM: doesn't start with numeric group ID pattern or explicitly marked as single user
+			const isDM = !threadIDStr.match(/^\d{15,}$/) || isSingleUser === true;
+			
+			// This means that threadID is the id of a user, and the chat
+			// is a single person chat
+			if (isDM) {
+				form["specific_to_list[0]"] = "fbid:" + threadID;
+				form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+				form["other_user_fbid"] = threadID;
+			} else {
+				form["thread_fbid"] = threadID;
+			}
+		}
+
+		if (ctx.globalOptions.pageID) {
+			form["author"] = "fbid:" + ctx.globalOptions.pageID;
+			form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
+			form["creator_info[creatorID]"] = ctx.userID;
+			form["creator_info[creatorType]"] = "direct_admin";
+			form["creator_info[labelType]"] = "sent_message";
+			form["creator_info[pageID]"] = ctx.globalOptions.pageID;
+			form["request_user_id"] = ctx.globalOptions.pageID;
+			form["creator_info[profileURI]"] =
+				"https://www.facebook.com/profile.php?id=" + ctx.userID;
+		}
+
+		const resData = await defaultFuncs.post("https://www.facebook.com/messaging/send/", ctx.jar, form).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+		if (!resData) {
+			throw new Error("Send message failed.");
+		}
+		if (resData.error) {
+			if (resData.error === 1545012) {
+				utils.warn("sendMessage", "Got error 1545012. This might mean that you're not part of the conversation " + threadID);
+				throw new Error(`Cannot send message to thread ${threadID}: Bot is not part of this conversation (Error 1545012)`);
+			}
+			throw new Error(resData);
+		}
+		const messageInfo = resData.payload.actions.reduce((p, v) => {
+				return { threadID: v.thread_fbid, messageID: v.message_id, timestamp: v.timestamp } || p;
+		}, null);
+		return messageInfo;
+	}
+
+	return async (msg, threadID, callback, replyToMessage, isSingleUser = null) => {
+		// Handle different parameter patterns for backward compatibility
+		if (typeof callback === "string" || (callback && typeof callback === "object")) {
+			// callback is actually replyToMessage, shift parameters
+			isSingleUser = replyToMessage;
+			replyToMessage = callback;
+			callback = function() {};
+		} else if (typeof callback !== "function") {
+			callback = function() {};
+		}
+
+		let msgType = utils.getType(msg);
+		let threadIDType = utils.getType(threadID);
+		let messageIDType = utils.getType(replyToMessage);
+		if (msgType !== "String" && msgType !== "Object") throw new Error("Message should be of type string or object and not " + msgType + ".");
+		if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String") throw new Error("ThreadID should be of type number, string, or array and not " + threadIDType + ".");
+		if (replyToMessage && messageIDType !== 'String' && messageIDType !== 'string') throw new Error("MessageID should be of type string and not " + messageIDType + ".");
+		if (msgType === "String") {
+			msg = { body: msg };
+		}
+		
+		// Auto-detect if this is a DM if not explicitly specified
+		if (isSingleUser === null && ctx.threadTypes && ctx.threadTypes[threadID]) {
+			isSingleUser = ctx.threadTypes[threadID] === 'dm';
+		} else if (isSingleUser === null) {
+			// Fallback: check if threadID looks like a user ID (15 digits) vs group ID (longer)
+			const threadIDStr = threadID.toString();
+			isSingleUser = threadIDStr.length === 15 || !threadIDStr.match(/^\d{16,}$/);
+		}
+		let disallowedProperties = Object.keys(msg).filter(prop => !allowedProperties[prop]);
+		if (disallowedProperties.length > 0) {
+			throw new Error("Dissallowed props: `" + disallowedProperties.join(", ") + "`");
+		}
+		let messageAndOTID = utils.generateOfflineThreadingID();
+		let form = {
+			client: "mercury",
+			action_type: "ma-type:user-generated-message",
+			author: "fbid:" + ctx.userID,
+			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_filtered_content_bh: false,
+			is_filtered_content_account: false,
+			is_filtered_content_quasar: false,
+			is_filtered_content_invalid_app: false,
+			is_spoof_warning: false,
+			source: "source:chat:web",
+			"source_tags[0]": "source:chat",
+			...(msg.body && {
+					body: msg.body
+			}),
+			html_body: false,
+			ui_push_phase: "V3",
+			status: "0",
+			offline_threading_id: messageAndOTID,
+			message_id: messageAndOTID,
+			threading_id: utils.generateThreadingID(ctx.clientID),
+			"ephemeral_ttl_mode:": "0",
+			manual_retry_cnt: "0",
+			has_attachment: !!(msg.attachment || msg.url || msg.sticker),
+			signatureID: utils.getSignatureID(),
+			...(replyToMessage && {
+					replied_to_message_id: replyToMessage
+			})
+		};
+
+		if (msg.location) {
+			if (!msg.location.latitude || !msg.location.longitude) throw new Error("location property needs both latitude and longitude");
+			form["location_attachment[coordinates][latitude]"] = msg.location.latitude;
+			form["location_attachment[coordinates][longitude]"] = msg.location.longitude;
+			form["location_attachment[is_current_location]"] = !!msg.location.current;
+		}
+		if (msg.sticker) {
+			form["sticker_id"] = msg.sticker;
+		}
+		if (msg.attachment) {
+			form.image_ids = [];
+			form.gif_ids = [];
+			form.file_ids = [];
+			form.video_ids = [];
+			form.audio_ids = [];
+			if (utils.getType(msg.attachment) !== "Array") {
+				msg.attachment = [msg.attachment];
+			}
+			const files = await uploadAttachment(msg.attachment);
+			files.forEach(file => {
+					const type = Object.keys(file)[0];
+					form["" + type + "s"].push(file[type]);
+			}); 
+		}
+		if (msg.url) {
+			form["shareable_attachment[share_type]"] = "100";
+			const params = await getUrl(msg.url);
+			form["shareable_attachment[share_params]"] = params;
+		}
+		if (msg.emoji) {
+			if (!msg.emojiSize) {
+				msg.emojiSize = "medium";
+			}
+			if (msg.emojiSize !== "small" && msg.emojiSize !== "medium" && msg.emojiSize !== "large") {
+				throw new Error("emojiSize property is invalid");
+			}
+			if (!form.body) {
+				throw new Error("body is not empty");
+			}
+			form.body = msg.emoji;
+			form["tags[0]"] = "hot_emoji_size:" + msg.emojiSize;
+		} 
+		if (msg.mentions) {
+			for (let i = 0; i < msg.mentions.length; i++) {
+				const mention = msg.mentions[i];
+				const tag = mention.tag;
+				if (typeof tag !== "string") {
+					throw new Error("Mention tags must be strings.");
+				}
+				const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+				if (offset < 0) utils.warn("handleMention", 'Mention for "' + tag + '" not found in message string.');
+				if (!mention.id) utils.warn("handleMention", "Mention id should be non-null.");
+				const id = mention.id || 0;
+				const emptyChar = '\u200E';
+				form["body"] = emptyChar + msg.body;
+				form["profile_xmd[" + i + "][offset]"] = offset + 1;
+				form["profile_xmd[" + i + "][length]"] = tag.length;
+				form["profile_xmd[" + i + "][id]"] = id;
+				form["profile_xmd[" + i + "][type]"] = "p";
+			}
+		}
+		const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
+		if (callback && typeof callback === "function") {
+			callback(null, result);
+		}
+		return result;
+	};
+};

package/src/share.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const utils = require('../utils');
+
+function formatPreviewResult(data) {
+    if (data.errors) {
+        throw data.errors[0];
+    }
+    const previewData = data.data?.xma_preview_data;
+    if (!previewData) {
+        throw { error: "Could not generate a preview for this post." };
+    }
+    return {
+        postID: previewData.post_id,
+        header: previewData.header_title,
+        subtitle: previewData.subtitle_text,
+        title: previewData.title_text,
+        previewImage: previewData.preview_url,
+        favicon: previewData.favicon_url,
+        headerImage: previewData.header_image_url
+    };
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+    return async function getPostPreview(postID, callback) {
+        let cb;
+        const returnPromise = new Promise((resolve, reject) => {
+            cb = (err, data) => err ? reject(err) : resolve(data);
+        });
+        
+        if (typeof callback === 'function') cb = callback;
+        if (!postID) {
+            return cb({ error: "A postID is required to generate a preview." });
+        }
+
+        const variables = {
+            shareable_id: postID.toString(),
+            scale: 3,
+        };
+
+        const form = {
+            fb_api_caller_class: 'RelayModern',
+            fb_api_req_friendly_name: 'CometXMAProxyShareablePreviewQuery',
+            variables: JSON.stringify(variables),
+            doc_id: '28939050904374351'
+        };
+
+        try {
+            const resData = await defaultFuncs
+                .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            
+            const result = formatPreviewResult(resData);
+            return cb(null, result);
+        } catch (err) {
+            utils.error("getPostPreview", err);
+            return cb(err);
+        }
+
+        return returnPromise;
+    };
+};

package/src/shareContact.js

@@ -4,39 +4,87 @@
 // fixed by kenneth panio
 
 var utils = require("../utils");
+var log = require("npmlog");
 
 module.exports = function(defaultFuncs, api, ctx) {
   return function shareContact(text, senderID, threadID, callback) {
+    let _callback;
+    let _resolvePromise;
+    let _rejectPromise;
+    
+    const returnPromise = new Promise((resolve, reject) => {
+      _resolvePromise = resolve;
+      _rejectPromise = reject;
+    });
+
+    // Setup callback with Promise support
+    if (typeof callback === 'function') {
+      _callback = (err, data) => {
+        if (err) {
+          callback(err);
+          _rejectPromise(err);
+        } else {
+          callback(null, data);
+          _resolvePromise(data);
+        }
+      };
+    } else {
+      _callback = (err, data) => {
+        if (err) _rejectPromise(err);
+        else _resolvePromise(data);
+      };
+    }
+
+    // Validation
     if (!ctx.mqttClient) {
-      throw new Error('Not connected to MQTT');
+      const error = new Error('Not connected to MQTT');
+      log.error('shareContact', error);
+      _callback(error);
+      return returnPromise;
+    }
+
+    if (!senderID) {
+      const error = new Error('senderID is required');
+      log.error('shareContact', error);
+      _callback(error);
+      return returnPromise;
+    }
+
+    if (!threadID) {
+      const error = new Error('threadID is required');
+      log.error('shareContact', error);
+      _callback(error);
+      return returnPromise;
     }
 
-    ctx.wsReqNumber ??= 0;
-    ctx.wsTaskNumber ??= 0;
+    // Initialize counters (fixed for compatibility)
+    ctx.wsReqNumber = ctx.wsReqNumber || 0;
+    ctx.wsTaskNumber = ctx.wsTaskNumber || 0;
+    ctx.callback_Task = ctx.callback_Task || {};
 
     ctx.wsReqNumber += 1;
     ctx.wsTaskNumber += 1;
 
     const queryPayload = {
-      contact_id: senderID,
+      contact_id: String(senderID),
       sync_group: 1,
       text: text || "",
-      thread_id: threadID
+      thread_id: String(threadID)
     };
 
     const query = {
       failure_count: null,
       label: '359',
       payload: JSON.stringify(queryPayload),
-      queue_name: 'messenger_contact_sharing',//xma_open_contact_share
-      task_id: Math.random() * 1001 << 0,
+      queue_name: String(threadID),  // Use threadID for queue_name
+      task_id: ctx.wsTaskNumber,     // Use consistent counter instead of random
     };
 
     const context = {
-      app_id: '2220391788200892',
+      app_id: ctx.appID || '2220391788200892',
       payload: {
         tasks: [query],
-        epoch_id: utils.generateOfflineThreadingID(),
+        epoch_id: parseInt(utils.generateOfflineThreadingID()) || Date.now(),
         version_id: '7214102258676893',
       },
       request_id: ctx.wsReqNumber,
@@ -45,66 +93,22 @@ module.exports = function(defaultFuncs, api, ctx) {
 
     context.payload = JSON.stringify(context.payload);
 
-    if (typeof callback === 'function') {
-      ctx.callback_Task[ctx.wsReqNumber] = { callback, type: "shareContact" };
-    }
-
-    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false });
-  };
-};
-
-/*"use strict";
-
-
-var utils = require("../utils");
-
-// @NethWs3Dev
+    // Store callback for response
+    ctx.callback_Task[ctx.wsReqNumber] = { 
+      callback: _callback, 
+      type: "shareContact" 
+    };
 
+    log.info('shareContact', `Sharing contact ${senderID} to thread ${threadID}`);
 
-module.exports = function (defaultFuncs, api, ctx) {
-	return async function shareContact(text, senderID, threadID, callback) {
-await utils.parseAndCheckLogin(ctx, defaultFuncs);
-        const mqttClient = ctx.mqttClient;
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        log.error('shareContact', `MQTT publish failed: ${err.message || err}`);
+        delete ctx.callback_Task[ctx.wsReqNumber];
+        _callback(new Error(`MQTT publish failed: ${err.message || err}`));
+      }
+    });
 
-        if (!mqttClient) {
-            throw new Error("Not connected to MQTT");
-        }
-		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);
-	data		};
-		}
-		let count_req = 0
-		var form = JSON.stringify({
-						"app_id": "2220391788200892",
-						"payload": JSON.stringify({
-								tasks: [{
-										label: '359',
-										payload: JSON.stringify({
-											"contact_id": senderID,
-											"sync_group": 1,
-											"text": text || "",
-											"thread_id": threadID
-										}),
-										queue_name: 'messenger_contact_sharing',
-										task_id: Math.random() * 1001 << 0,
-										failure_count: null,
-								}],
-								epoch_id: utils.generateOfflineThreadingID(),
-								version_id: '7214102258676893',
-						}),
-						"request_id": ++count_req,
-						"type": 3
-				});
-		mqttClient.publish('/ls_req',form)
-
-		return returnPromise;
-	};
-};*/
+    return returnPromise;
+  };
+};

package/src/shareContact.js.bak

@@ -0,0 +1,110 @@
+/* eslint-disable linebreak-style */
+"use strict";
+
+// fixed by kenneth panio
+
+var utils = require("../utils");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function shareContact(text, senderID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber ??= 0;
+    ctx.wsTaskNumber ??= 0;
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      contact_id: senderID,
+      sync_group: 1,
+      text: text || "",
+      thread_id: threadID
+    };
+
+    const query = {
+      failure_count: null,
+      label: '359',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'messenger_contact_sharing',//xma_open_contact_share
+      task_id: Math.random() * 1001 << 0,
+    };
+
+    const context = {
+      app_id: '2220391788200892',
+      payload: {
+        tasks: [query],
+        epoch_id: utils.generateOfflineThreadingID(),
+        version_id: '7214102258676893',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    context.payload = JSON.stringify(context.payload);
+
+    if (typeof callback === 'function') {
+      ctx.callback_Task[ctx.wsReqNumber] = { callback, type: "shareContact" };
+    }
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false });
+  };
+};
+
+/*"use strict";
+
+
+var utils = require("../utils");
+
+// @NethWs3Dev
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return async function shareContact(text, senderID, threadID, callback) {
+await utils.parseAndCheckLogin(ctx, defaultFuncs);
+        const mqttClient = ctx.mqttClient;
+
+        if (!mqttClient) {
+            throw new Error("Not connected to MQTT");
+        }
+		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);
+	data		};
+		}
+		let count_req = 0
+		var form = JSON.stringify({
+						"app_id": "2220391788200892",
+						"payload": JSON.stringify({
+								tasks: [{
+										label: '359',
+										payload: JSON.stringify({
+											"contact_id": senderID,
+											"sync_group": 1,
+											"text": text || "",
+											"thread_id": threadID
+										}),
+										queue_name: 'messenger_contact_sharing',
+										task_id: Math.random() * 1001 << 0,
+										failure_count: null,
+								}],
+								epoch_id: utils.generateOfflineThreadingID(),
+								version_id: '7214102258676893',
+						}),
+						"request_id": ++count_req,
+						"type": 3
+				});
+		mqttClient.publish('/ls_req',form)
+
+		return returnPromise;
+	};
+};*/