shadowx-fca 8.0.0

package/src/sendMessage.js

@@ -0,0 +1,487 @@
+"use strict";
+
+var utils = require("../utils");
+var logger = require("../logger");
+
+var ALLOWED = {
+    attachment: true, url: true, sticker: true, emoji: true,
+    emojiSize: true, body: true, mentions: true, location: true,
+    replyToMessage: true, forwardAttachmentIds: true
+};
+
+var EMOJI_SIZES = { small: 1, medium: 2, large: 3 };
+
+function toEmojiSize(size) {
+    if (typeof size === "number" && !isNaN(size)) return Math.min(3, Math.max(1, size));
+    if (typeof size === "string" && size in EMOJI_SIZES) return EMOJI_SIZES[size];
+    return 1;
+}
+
+function hasLinks(text) {
+    return /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(text);
+}
+
+function buildMentionData(msg, baseBody) {
+    if (!Array.isArray(msg.mentions) || !msg.mentions.length) return null;
+    var ids = [], offsets = [], lengths = [], types = [];
+    for (var i = 0; i < msg.mentions.length; i++) {
+        var mention = msg.mentions[i];
+        var tag = String(mention.tag || "");
+        if (tag && !tag.startsWith("@")) tag = "@" + tag;
+        var fromIndex = Number.isInteger(mention.fromIndex) ? mention.fromIndex : 0;
+        var offset = baseBody.indexOf(tag, fromIndex);
+        if (offset === -1) {
+            offset = baseBody.indexOf(tag.slice(1), fromIndex);
+        }
+        if (offset < 0) offset = 0;
+        ids.push(String(mention.id || 0));
+        offsets.push(offset);
+        lengths.push(tag.length);
+        types.push("p");
+    }
+    return {
+        mention_ids: ids.join(","),
+        mention_offsets: offsets.join(","),
+        mention_lengths: lengths.join(","),
+        mention_types: types.join(",")
+    };
+}
+
+function extractIdsFromPayload(payload) {
+    var messageID = null, threadID = null;
+    function walk(node) {
+        if (!Array.isArray(node)) return;
+        if (node[0] === 5 && (node[1] === "replaceOptimsiticMessage" || node[1] === "replaceOptimisticMessage")) {
+            messageID = String(node[3]);
+        }
+        if (node[0] === 5 && node[1] === "writeCTAIdToThreadsTable") {
+            var candidate = node[2];
+            if (Array.isArray(candidate) && candidate[0] === 19) threadID = String(candidate[1]);
+        }
+        for (var i = 0; i < node.length; i++) walk(node[i]);
+    }
+    try { walk(payload && payload.step); } catch (_) { }
+    return { threadID, messageID };
+}
+
+function publishLsRequestWithAck(mqttClient, content, requestId, timeout) {
+    timeout = timeout || 15000;
+    return new Promise((resolve, reject) => {
+        var timer = setTimeout(() => {
+            mqttClient.removeListener('message', onMessage);
+            reject(new Error('MQTT sendMessage timed out after ' + timeout + 'ms'));
+        }, timeout);
+
+        function onMessage(topic, message) {
+            if (topic !== '/ls_resp') return;
+            try {
+                var data = JSON.parse(message.toString());
+                if (String(data.request_id) === String(requestId)) {
+                    clearTimeout(timer);
+                    mqttClient.removeListener('message', onMessage);
+                    var extracted = extractIdsFromPayload(data.payload ? JSON.parse(data.payload) : {});
+                    resolve({ threadID: extracted.threadID, messageID: extracted.messageID });
+                }
+            } catch (_) { }
+        }
+
+        mqttClient.on('message', onMessage);
+        mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1 }, err => {
+            if (err) {
+                clearTimeout(timer);
+                mqttClient.removeListener('message', onMessage);
+                reject(err);
+            }
+        });
+    });
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    // HTTP-based upload for OldMessage fallback
+    async function uploadAttachmentHTTP(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]) + ".");
+            }
+            var formData = { upload_1024: attachments[i], voice_clip: "true" };
+            var resData = await defaultFuncs
+                .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, formData, {})
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            if (!resData || resData.error) {
+                throw new Error(resData ? resData.error : "Upload failed");
+            }
+            uploads.push(resData.payload.metadata[0]);
+        }
+        return uploads;
+    }
+
+    // MQTT-based upload using uploadAttachment module
+    var uploadAttachmentMQTT = require('./uploadAttachment')(defaultFuncs, api, ctx);
+    
+    async function uploadAttachmentsMQTT(attachments) {
+        if (!Array.isArray(attachments)) attachments = [attachments];
+        return uploadAttachmentMQTT(attachments);
+    }
+
+    // URL sharing helper for HTTP path
+    async function getShareUrl(url) {
+        var 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 ? resData.error : "Failed to get share URL");
+        }
+        return resData.payload.share_params;
+    }
+
+    // MQTT send path
+    async function sendViaMqtt(msg, threadID, replyToMessage) {
+        var mqttClient = ctx.mqttClient || global.mqttClient;
+        if (!mqttClient) throw new Error('MQTT client not available');
+
+        var baseBody = msg.body != null ? String(msg.body) : "";
+        var requestId = Math.floor(100 + Math.random() * 900);
+        var epoch = (BigInt(Date.now()) << 22n).toString();
+
+        var payload0 = {
+            thread_id: String(threadID),
+            otid: utils.generateOfflineThreadingID(),
+            source: 2097153,
+            send_type: 1,
+            sync_group: 1,
+            mark_thread_read: 1,
+            text: baseBody === "" ? null : baseBody,
+            initiating_source: 0,
+            skip_url_preview_gen: 0,
+            text_has_links: hasLinks(baseBody) ? 1 : 0,
+            multitab_env: 0,
+            metadata_dataclass: JSON.stringify({ media_accessibility_metadata: { alt_text: null } })
+        };
+
+        var mentionData = buildMentionData(msg, baseBody);
+        if (mentionData) payload0.mention_data = mentionData;
+
+        if (msg.sticker) { 
+            payload0.send_type = 2; 
+            payload0.sticker_id = msg.sticker; 
+        }
+        if (msg.emoji) { 
+            payload0.send_type = 1; 
+            payload0.text = msg.emoji; 
+            payload0.hot_emoji_size = toEmojiSize(msg.emojiSize); 
+        }
+
+        if (msg.location && msg.location.latitude != null && msg.location.longitude != null) {
+            payload0.send_type = 1;
+            payload0.location_data = {
+                coordinates: { latitude: msg.location.latitude, longitude: msg.location.longitude },
+                is_current_location: Boolean(msg.location.current),
+                is_live_location: Boolean(msg.location.live)
+            };
+        }
+
+        var effectiveReplyTo = replyToMessage || msg.replyToMessage;
+        if (effectiveReplyTo) {
+            payload0.reply_metadata = {
+                reply_source_id: effectiveReplyTo,
+                reply_source_type: 1,
+                reply_type: 0
+            };
+        }
+
+        if (msg.url) {
+            // URL sharing via MQTT
+            payload0.send_type = 1;
+            payload0.link_share = {
+                share_type: 100,
+                share_params: await getShareUrl(msg.url)
+            };
+        }
+
+        if (msg.attachment) {
+            payload0.send_type = 3;
+            if (payload0.text === "") payload0.text = null;
+            payload0.attachment_fbids = [];
+            var list = Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment];
+            var preuploaded = [], toUpload = [];
+            for (var item of list) {
+                if (Array.isArray(item) && item.length >= 2 && typeof item[0] === "string") {
+                    preuploaded.push(String(item[1]));
+                } else if (utils.isReadableStream(item)) {
+                    toUpload.push(item);
+                }
+            }
+            if (preuploaded.length) payload0.attachment_fbids = payload0.attachment_fbids.concat(preuploaded);
+            if (msg.forwardAttachmentIds && msg.forwardAttachmentIds.length) {
+                payload0.attachment_fbids = payload0.attachment_fbids.concat(msg.forwardAttachmentIds.map(String));
+            }
+
+            if (toUpload.length) {
+                var uploaded = await uploadAttachmentsMQTT(toUpload);
+                for (var u of uploaded) {
+                    if (!u) continue;
+                    var fbid = u.image_id || u.video_id || u.audio_id || u.file_id || u.sticker_id || u.gif_id;
+                    if (!fbid) {
+                        var firstKey = Object.keys(u).find(function(k) { return u[k] && /^\d+$/.test(String(u[k])); });
+                        if (firstKey) fbid = u[firstKey];
+                    }
+                    if (fbid) payload0.attachment_fbids.push(String(fbid));
+                }
+            }
+            if (!payload0.attachment_fbids.length) delete payload0.attachment_fbids;
+        }
+
+        var tasks = [
+            {
+                label: '46',
+                payload: JSON.stringify(payload0),
+                queue_name: String(threadID),
+                task_id: 400,
+                failure_count: null
+            },
+            {
+                label: '21',
+                payload: JSON.stringify({
+                    thread_id: String(threadID),
+                    last_read_watermark_ts: Date.now(),
+                    sync_group: 1
+                }),
+                queue_name: String(threadID),
+                task_id: 401,
+                failure_count: null
+            }
+        ];
+
+        var content = {
+            app_id: '2220391788200892',
+            payload: JSON.stringify({
+                tasks: tasks,
+                epoch_id: epoch,
+                version_id: '24804310205905615',
+                data_trace_id: '#' + Buffer.from(String(Math.random())).toString('base64').replace(/=+$/, '')
+            }),
+            request_id: requestId,
+            type: 3
+        };
+
+        return publishLsRequestWithAck(mqttClient, content, requestId, 15000);
+    }
+
+    // HTTP send path (OldMessage style)
+    async function sendViaHTTP(msg, threadID, isSingleUser, replyToMessage) {
+        var messageAndOTID = utils.generateOfflineThreadingID();
+        var 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",
+            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(),
+            replied_to_message_id: replyToMessage || ""
+        };
+
+        var threadIDStr = threadID.toString();
+        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;
+        } else {
+            if (isSingleUser) {
+                form["specific_to_list[0]"] = "fbid:" + threadIDStr;
+                form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+                form["other_user_fbid"] = threadIDStr;
+            } else {
+                form["thread_fbid"] = threadIDStr;
+            }
+        }
+
+        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;
+        }
+
+        if (msg.location) {
+            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.emoji) {
+            form.body = msg.emoji;
+            form["tags[0]"] = "hot_emoji_size:" + (msg.emojiSize || "medium");
+        }
+
+        if (msg.mentions) {
+            for (var j = 0; j < msg.mentions.length; j++) {
+                var mention = msg.mentions[j];
+                var tag = mention.tag;
+                var offset = (msg.body || "").indexOf(tag, mention.fromIndex || 0);
+                if (offset < 0) {
+                    logger.warn("sendMessage", 'Mention for "' + tag + '" not found in message string.');
+                }
+                form["profile_xmd[" + j + "][offset]"] = offset + 1;
+                form["profile_xmd[" + j + "][length]"] = tag.length;
+                form["profile_xmd[" + j + "][id]"] = mention.id || 0;
+                form["profile_xmd[" + j + "][type]"] = "p";
+            }
+        }
+
+        if (msg.attachment) {
+            form.image_ids = [];
+            form.gif_ids = [];
+            form.file_ids = [];
+            form.video_ids = [];
+            form.audio_ids = [];
+            var attachments = utils.getType(msg.attachment) !== "Array" ? [msg.attachment] : msg.attachment;
+            var files = await uploadAttachmentHTTP(attachments);
+            files.forEach(function(file) {
+                var type = Object.keys(file)[0];
+                form[type + "s"].push(file[type]);
+            });
+        }
+
+        if (msg.url) {
+            form["shareable_attachment[share_type]"] = "100";
+            form["shareable_attachment[share_params]"] = await getShareUrl(msg.url);
+        }
+
+        var 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) {
+                throw new Error("Cannot send message to thread " + threadID + ": Bot is not part of this conversation (Error 1545012)");
+            }
+            throw new Error(resData.error);
+        }
+
+        return resData.payload.actions.reduce(function(p, v) {
+            return { threadID: v.thread_fbid, messageID: v.message_id, timestamp: v.timestamp } || p;
+        }, null);
+    }
+
+    return async function sendMessage(msg, threadID, callback, replyToMessage, isSingleUser) {
+        // Normalize parameters
+        if (typeof callback === "string" || (callback && typeof callback === "object")) {
+            isSingleUser = replyToMessage;
+            replyToMessage = callback;
+            callback = function() {};
+        }
+        if (typeof msg === "string") msg = { body: msg };
+        if (typeof callback !== "function") callback = null;
+
+        var resolve, reject;
+        var promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+
+        // Validate properties
+        for (var key in msg) {
+            if (!ALLOWED[key]) {
+                var err = { error: "sendMessage: Unknown property '" + key + "'" };
+                if (callback) callback(err);
+                else reject(err);
+                return promise;
+            }
+        }
+
+        // Auto-detect isSingleUser from ctx.threadTypes if not explicitly provided
+        if (isSingleUser === undefined && ctx.threadTypes) {
+            isSingleUser = ctx.threadTypes[String(threadID)] === 'dm';
+        }
+        if (isSingleUser === undefined) {
+            var threadIDStr = threadID.toString();
+            isSingleUser = threadIDStr.length === 15 || !threadIDStr.match(/^\d{16,}$/);
+        }
+
+        // DM attachment sends — route appropriately
+        if (isSingleUser && msg.attachment) {
+            var useE2EE = api.e2ee && typeof api.e2ee.isConnected === "function" && api.e2ee.isConnected();
+            if (useE2EE) {
+                try {
+                    var e2eeResult = await api.e2ee.sendMessage(String(threadID), msg, replyToMessage);
+                    var wrapped = e2eeResult && e2eeResult.messageId
+                        ? { threadID: String(threadID), messageID: String(e2eeResult.messageId) }
+                        : e2eeResult;
+                    if (callback) callback(null, wrapped);
+                    else resolve(wrapped);
+                } catch (e2eeErr) {
+                    logger.error("sendMessage", "E2EE DM attachment send failed: " + (e2eeErr.message || e2eeErr));
+                    if (callback) callback(e2eeErr);
+                    else reject(e2eeErr);
+                }
+            } else {
+                try {
+                    var httpResult = await sendViaHTTP(msg, threadID, true, replyToMessage);
+                    if (callback) callback(null, httpResult);
+                    else resolve(httpResult);
+                } catch (httpErr) {
+                    logger.error("sendMessage", "DM attachment via HTTP failed: " + (httpErr.error || httpErr.message || httpErr));
+                    if (callback) callback(httpErr);
+                    else reject(httpErr);
+                }
+            }
+            return promise;
+        }
+
+        // Try MQTT first, fallback to HTTP
+        try {
+            var mqttResult = await sendViaMqtt(msg, threadID, replyToMessage);
+            if (callback) callback(null, mqttResult);
+            else resolve(mqttResult);
+        } catch (mqttErr) {
+            logger.warn("sendMessage", "MQTT failed, falling back to HTTP: " + (mqttErr.message || mqttErr));
+            try {
+                var httpResult = await sendViaHTTP(msg, threadID, isSingleUser, replyToMessage);
+                if (callback) callback(null, httpResult);
+                else resolve(httpResult);
+            } catch (httpErr) {
+                logger.error("sendMessage", "HTTP fallback also failed: " + (httpErr.error || httpErr.message || httpErr));
+                if (callback) callback(httpErr);
+                else reject(httpErr);
+            }
+        }
+
+        return promise;
+    };
+};