@lazyneoaz/testfca 1.0.0

package/src/apis/createAITheme.js

@@ -0,0 +1,129 @@
+/**
+ * @by Allou Mohamed
+ * do not remove the author name to get more updates
+ */
+
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function createAITheme(prompt, numThemes, callback) {
+    if (typeof numThemes === 'function') {
+      callback = numThemes;
+      numThemes = 3;
+    }
+    if (typeof numThemes !== 'number' || numThemes < 1) {
+      numThemes = 3;
+    }
+    if (numThemes > 10) {
+      numThemes = 10;
+    }
+
+    const form = {
+      av: ctx.i_userID || ctx.userID,
+      qpl_active_flow_ids: "25308101,25309433,521482085",
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+      variables: JSON.stringify({
+        input: {
+          client_mutation_id: "1",
+          actor_id: ctx.i_userID || ctx.userID,
+          bypass_cache: true,
+          caller: "MESSENGER",
+          num_themes: numThemes,
+          prompt: prompt
+        }
+      }),
+      server_timestamps: true,
+      doc_id: "23873748445608673",
+      fb_api_analytics_tags: JSON.stringify([
+        "qpl_active_flow_ids=25308101,25309433,521482085"
+      ]),
+      fb_dtsg: ctx.fb_dtsg
+    };
+
+    const extractUrl = (obj) => {
+      if (!obj) return null;
+      if (typeof obj === 'string') return obj;
+      return obj.uri || obj.url || null;
+    };
+
+    const normalizeTheme = (theme) => {
+      const normalized = { ...theme };
+
+      let lightUrl = null;
+      let darkUrl = null;
+
+      const previewUrls = theme.preview_image_urls || theme.preview_images || theme.preview_urls;
+
+      if (previewUrls) {
+        if (typeof previewUrls === 'string') {
+          lightUrl = darkUrl = previewUrls;
+        } else if (Array.isArray(previewUrls)) {
+          lightUrl = extractUrl(previewUrls[0]) || null;
+          darkUrl = extractUrl(previewUrls[1]) || lightUrl;
+        } else if (typeof previewUrls === 'object') {
+          lightUrl = extractUrl(previewUrls.light_mode) || extractUrl(previewUrls.light) || null;
+          darkUrl = extractUrl(previewUrls.dark_mode) || extractUrl(previewUrls.dark) || null;
+        }
+      }
+
+      if (!lightUrl && theme.background_asset && theme.background_asset.image) {
+        lightUrl = extractUrl(theme.background_asset.image);
+      }
+      if (!lightUrl && theme.icon_asset && theme.icon_asset.image) {
+        lightUrl = extractUrl(theme.icon_asset.image);
+      }
+
+      if (!darkUrl && theme.alternative_themes && theme.alternative_themes.length > 0) {
+        const darkTheme = theme.alternative_themes[0];
+        if (darkTheme.background_asset && darkTheme.background_asset.image) {
+          darkUrl = extractUrl(darkTheme.background_asset.image);
+        }
+        if (!darkUrl && darkTheme.icon_asset && darkTheme.icon_asset.image) {
+          darkUrl = extractUrl(darkTheme.icon_asset.image);
+        }
+      }
+
+      if (lightUrl && !darkUrl) {
+        darkUrl = lightUrl;
+      } else if (darkUrl && !lightUrl) {
+        lightUrl = darkUrl;
+      }
+
+      if (lightUrl || darkUrl) {
+        normalized.preview_image_urls = {
+          light_mode: lightUrl,
+          dark_mode: darkUrl
+        };
+      }
+
+      return normalized;
+    };
+
+    const promise = defaultFuncs
+      .post("https://web.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.errors) {
+          throw resData.errors;
+        }
+        const themes = resData.data.xfb_generate_ai_themes_from_prompt.themes;
+        return themes.map(normalizeTheme);
+      });
+
+    if (callback) {
+      promise.then(data => callback(null, data)).catch(err => {
+        utils.error("createAITheme", err.message || err);
+        callback(err);
+      });
+      return;
+    }
+
+    return promise.catch(err => {
+      utils.error("createAITheme", err.message || err);
+      throw err;
+    });
+  };
+};

package/src/apis/createNewGroup.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createNewGroup(participantIDs, groupTitle, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(groupTitle) === "Function") {
+        callback = groupTitle;
+        groupTitle = null;
+      }
+
+      if (utils.getType(participantIDs) !== "Array") {
+        throw new Error("createNewGroup: participantIDs should be an array.");
+      }
+
+      if (participantIDs.length < 2) {
+        throw new Error("createNewGroup: participantIDs should have at least 2 IDs.");
+      }
+
+      const pids = [];
+      for (const n in participantIDs) {
+        pids.push({
+          fbid: participantIDs[n]
+        });
+      }
+      pids.push({ fbid: ctx.i_userID || ctx.userID });
+
+      const form = {
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "MessengerGroupCreateMutation",
+        av: ctx.i_userID || ctx.userID,
+        doc_id: "577041672419534",
+        variables: JSON.stringify({
+          input: {
+            entry_point: "jewel_new_group",
+            actor_id: ctx.i_userID || ctx.userID,
+            participants: pids,
+            client_mutation_id: Math.round(Math.random() * 1024).toString(),
+            thread_settings: {
+              name: groupTitle,
+              joinable_mode: "PRIVATE",
+              thread_image_fbid: null
+            }
+          }
+        })
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      const threadID = res.data.messenger_group_thread_create.thread.thread_key.thread_fbid;
+      callback(null, threadID);
+    } catch (err) {
+      utils.error("createNewGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/createPoll.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createPoll(threadID, questionText, options, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (!threadID || typeof threadID !== "string") {
+        throw new Error("Invalid threadID");
+      }
+
+      if (!questionText || typeof questionText !== "string") {
+        throw new Error("questionText must be a string");
+      }
+
+      if (!Array.isArray(options) || options.length < 2) {
+        throw new Error("options must be an array with at least 2 options");
+      }
+
+      const payload = {
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "163",
+            payload: JSON.stringify({
+              question_text: questionText,
+              thread_key: threadID,
+              options: options,
+              sync_group: 1
+            }),
+            queue_name: "poll_creation",
+            task_id: Math.floor(Math.random() * 1001)
+          }
+        ],
+        version_id: "8768858626531631"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: ++ctx.wsReqNumber,
+        type: 3
+      });
+
+      ctx.mqttClient.publish("/ls_req", form);
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("createPoll", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/deleteMessage.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteMessage(messageID, callback) {
+    // E2EE routing: deleteMessage({ chatJid, messageId })
+    if (utils.getType(messageID) === "Object" && messageID.chatJid && messageID.messageId) {
+      if (!api.e2ee || !api.e2ee.isAvailable()) throw new Error("E2EE bridge not available");
+      const p = api.e2ee.unsendE2EEMessage(messageID.chatJid, messageID.messageId);
+      if (callback) p.then(r => callback(null, r)).catch(callback);
+      return p;
+    }
+
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        message_id: messageID
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/delete_messages.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, { success: true });
+    } catch (err) {
+      utils.error("deleteMessage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/deleteThread.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteThread(threadOrThreads, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        client: "mercury"
+      };
+
+      if (utils.getType(threadOrThreads) !== "Array") {
+        threadOrThreads = [threadOrThreads];
+      }
+
+      for (let i = 0; i < threadOrThreads.length; i++) {
+        form["ids[" + i + "]"] = threadOrThreads[i];
+      }
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/delete_thread.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("deleteThread", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/e2ee.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const { bridge, getOrCreateHandle } = require('../e2ee');
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+    async function h(opts) {
+        return getOrCreateHandle(ctx, opts);
+    }
+
+    return {
+        isAvailable() {
+            return bridge.isAvailable();
+        },
+
+        async connect(options) {
+            const handle = await h(options);
+            return bridge.connect(handle);
+        },
+
+        async connectE2EE(options) {
+            const handle = await h(options);
+            return bridge.connectE2EE(handle);
+        },
+
+        async disconnect() {
+            if (ctx._e2eeBridgeHandle == null) return;
+            bridge.disconnect(ctx._e2eeBridgeHandle);
+            ctx._e2eeBridgeHandle = null;
+        },
+
+        isConnected() {
+            if (ctx._e2eeBridgeHandle == null) return { connected: false, e2eeConnected: false };
+            return bridge.isConnected(ctx._e2eeBridgeHandle);
+        },
+
+        getDeviceData() {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.getDeviceData(ctx._e2eeBridgeHandle).deviceData;
+        },
+
+        setDeviceData(deviceData) {
+            ctx._e2eeDeviceData = deviceData;
+        },
+
+        setDevicePath(devicePath) {
+            ctx._e2eeDevicePath = devicePath;
+        },
+
+        pollEvents(timeoutMs) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.pollEvents(ctx._e2eeBridgeHandle, timeoutMs || 5000);
+        },
+
+        sendE2EEMessage(chatJid, text, replyToId, replyToSenderJid) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected. Call connect() and connectE2EE() first.');
+            return bridge.sendE2EEMessage(ctx._e2eeBridgeHandle, chatJid, text, replyToId, replyToSenderJid);
+        },
+
+        sendE2EEReaction(chatJid, messageId, senderJid, emoji) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EEReaction(ctx._e2eeBridgeHandle, chatJid, messageId, senderJid, emoji);
+        },
+
+        sendE2EETyping(chatJid, isTyping) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EETyping(ctx._e2eeBridgeHandle, chatJid, isTyping);
+        },
+
+        editE2EEMessage(chatJid, messageId, newText) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.editE2EEMessage(ctx._e2eeBridgeHandle, chatJid, messageId, newText);
+        },
+
+        unsendE2EEMessage(chatJid, messageId) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.unsendE2EEMessage(ctx._e2eeBridgeHandle, chatJid, messageId);
+        },
+
+        sendE2EEImage(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EEImage(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendE2EEVideo(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EEVideo(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendE2EEAudio(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EEAudio(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendE2EEDocument(chatJid, data, filename, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EEDocument(ctx._e2eeBridgeHandle, { chatJid, data, filename, mimeType, ...(options || {}) });
+        },
+
+        sendE2EESticker(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendE2EESticker(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        downloadE2EEMedia(options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.downloadE2EEMedia(ctx._e2eeBridgeHandle, options);
+        },
+
+        uploadMedia(options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.uploadMedia(ctx._e2eeBridgeHandle, options);
+        },
+
+        sendImage(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendImage(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendVideo(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendVideo(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendVoice(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendVoice(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        sendFile(chatJid, data, filename, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendFile(ctx._e2eeBridgeHandle, { chatJid, data, filename, mimeType, ...(options || {}) });
+        },
+
+        sendSticker(chatJid, data, mimeType, options) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.sendSticker(ctx._e2eeBridgeHandle, { chatJid, data, mimeType, ...(options || {}) });
+        },
+
+        getCookies() {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.getCookies(ctx._e2eeBridgeHandle).cookies;
+        },
+
+        getUserInfo(userId) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.getUserInfo(ctx._e2eeBridgeHandle, userId);
+        },
+
+        createThread(userId) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.createThread(ctx._e2eeBridgeHandle, userId);
+        },
+
+        searchUsers(query) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.searchUsers(ctx._e2eeBridgeHandle, query);
+        },
+
+        markRead(chatJid, watermarkTs) {
+            if (ctx._e2eeBridgeHandle == null) throw new Error('E2EE not connected');
+            return bridge.markRead(ctx._e2eeBridgeHandle, chatJid, watermarkTs);
+        },
+
+        unload() {
+            bridge.unload();
+            ctx._e2eeBridgeHandle = null;
+        },
+    };
+};

package/src/apis/editMessage.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+* @author RFS-ADRENO
+* @rewrittenBy Isai Ivanov
+*/
+
+const utils = require('../utils');
+
+function canBeCalled(func) {
+    try {
+        Reflect.apply(func, null, []);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+* A function for editing bot's messages.
+* @param {string} text - The text with which the bot will edit its messages.
+* @param {string} messageID - The message ID of the message the bot will edit.
+* @param {Object} callback - Callback for the function.
+*/
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function editMessage(text, messageID, callback) {
+        // E2EE routing: editMessage(text, { chatJid, messageId }, callback)
+        if (utils.getType(messageID) === "Object" && messageID.chatJid && messageID.messageId) {
+            if (!api.e2ee || !api.e2ee.isAvailable()) throw new Error("E2EE bridge not available");
+            const p = api.e2ee.editE2EEMessage(messageID.chatJid, messageID.messageId, text);
+            if (callback) p.then(r => callback(null, r)).catch(callback);
+            return p;
+        }
+
+        if (!ctx.mqttClient) {
+            throw new Error('Not connected to MQTT');
+        }
+
+        ctx.wsReqNumber += 1;
+        ctx.wsTaskNumber += 1;
+
+        const queryPayload = {
+            message_id: messageID,
+            text
+        };
+
+        const query = {
+            failure_count: null,
+            label: '742',
+            payload: JSON.stringify(queryPayload),
+            queue_name: 'edit_message',
+            task_id: ctx.wsTaskNumber
+        };
+
+        const context = {
+            app_id: '2220391788200892',
+            payload: {
+                data_trace_id: null,
+                epoch_id: parseInt(utils.generateOfflineThreadingID()),
+                tasks: [query],
+                version_id: '6903494529735864'
+            },
+            request_id: ctx.wsReqNumber,
+            type: 3
+        };
+
+        context.payload = JSON.stringify(context.payload);
+
+
+
+
+
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {
+            qos: 1, retain: false
+        });
+    };
+};
+