@cexy/hoonfca 1.0.1 → 1.0.3

package/src/apis/mqttDeltaValue.js

@@ -1,278 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-const e2ee = require('../security/e2ee');
-
-
-function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
-  if (v.delta.class == "NewMessage") {
-
-    if (ctx.globalOptions.pageID && ctx.globalOptions.pageID != v.queue) return;
-    (function resolveAttachmentUrl(i) {
-      if (!v.delta.attachments || i == v.delta.attachments.length || utils.getType(v.delta.attachments) !== "Array") {
-        var fmtMsg;
-        try {
-          fmtMsg = utils.formatDeltaMessage(v);
-        } catch (err) {
-          return;
-        }
-        if (fmtMsg) {
-            try {
-              if (e2ee.isEnabled(ctx) && !!v.delta.threadKey.threadFbId) {
-                const dec = e2ee.decrypt(ctx, fmtMsg.threadID, fmtMsg.body);
-                if (dec !== null) fmtMsg.body = dec;
-              }
-            } catch (_) {}
-            if (ctx.globalOptions.autoMarkDelivery) {
-                api.markAsDelivered(fmtMsg.threadID, fmtMsg.messageID);
-            }
-            if (!ctx.globalOptions.selfListen && fmtMsg.senderID === ctx.userID) {
-                return;
-            }
-            return globalCallback(null, fmtMsg);
-        }
-      } else {
-         var attachment = v.delta.attachments[i];
-         if (attachment && attachment.mercury && attachment.mercury.attach_type == "photo") {
-          api.resolvePhotoUrl(attachment.fbid, (err, url) => {
-            if (!err) attachment.mercury.metadata.url = url;
-            return resolveAttachmentUrl(i + 1);
-          });
-         } else {
-            return resolveAttachmentUrl(i + 1);
-         }
-      }
-    })(0);
-  }
-
-  if (v.delta.class == "ClientPayload") {
-    var clientPayload = utils.decodeClientPayload(v.delta.payload);
-    if (clientPayload && clientPayload.deltas) {
-      for (var i in clientPayload.deltas) {
-        var delta = clientPayload.deltas[i];
-
-        if (delta.deltaMessageReaction && !!ctx.globalOptions.listenEvents) {
-            const reactionEvent = {
-              type: "message_reaction",
-              threadID: (delta.deltaMessageReaction.threadKey.threadFbId || delta.deltaMessageReaction.threadKey.otherUserFbId).toString(),
-              messageID: delta.deltaMessageReaction.messageId,
-              reaction: delta.deltaMessageReaction.reaction,
-              senderID: delta.deltaMessageReaction.userId.toString(),
-              userID: delta.deltaMessageReaction.userId.toString()
-            };
-
-            if (!ctx.globalOptions.selfListen && reactionEvent.senderID === ctx.userID) {
-              return;
-            }
-
-            globalCallback(null, reactionEvent);
-        } else if (delta.deltaRecallMessageData && !!ctx.globalOptions.listenEvents) {
-            globalCallback(null, {
-              type: "message_unsend",
-              threadID: (delta.deltaRecallMessageData.threadKey.threadFbId || delta.deltaRecallMessageData.threadKey.otherUserFbId).toString(),
-              messageID: delta.deltaRecallMessageData.messageID,
-              senderID: delta.deltaRecallMessageData.senderID.toString(),
-              deletionTimestamp: delta.deltaRecallMessageData.deletionTimestamp,
-              timestamp: delta.deltaRecallMessageData.timestamp
-            });
-        } else if (delta.deltaMessageReply) {
-          var mdata = delta.deltaMessageReply.message?.data?.prng ? JSON.parse(delta.deltaMessageReply.message.data.prng) : [];
-          var mentions = {};
-          if (mdata) {
-            mdata.forEach(m => mentions[m.i] = (delta.deltaMessageReply.message.body || "").substring(m.o, m.o + m.l));
-          }
-
-          var callbackToReturn = {
-            type: "message_reply",
-            threadID: (delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.message.messageMetadata.threadKey.otherUserFbId).toString(),
-            messageID: delta.deltaMessageReply.message.messageMetadata.messageId,
-            senderID: delta.deltaMessageReply.message.messageMetadata.actorFbId.toString(),
-            attachments: delta.deltaMessageReply.message.attachments.map(att => {
-              try {
-                var mercury = JSON.parse(att.mercuryJSON);
-                Object.assign(att, mercury);
-                return utils._formatAttachment(att);
-              } catch (ex) {
-                return { ...att, error: ex, type: "unknown" };
-              }
-            }),
-            body: (delta.deltaMessageReply.message.body || ""),
-            isGroup: !!delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId,
-            mentions: mentions,
-            timestamp: delta.deltaMessageReply.message.messageMetadata.timestamp,
-            participantIDs: (delta.deltaMessageReply.message.participants || []).map(e => e.toString())
-          };
-          try {
-            if (e2ee.isEnabled(ctx) && callbackToReturn.isGroup) {
-              const dec = e2ee.decrypt(ctx, callbackToReturn.threadID, callbackToReturn.body);
-              if (dec !== null) callbackToReturn.body = dec;
-            }
-          } catch (_) {}
-
-          if (delta.deltaMessageReply.repliedToMessage) {
-            var rmentions = {};
-            var rmdata = delta.deltaMessageReply.repliedToMessage?.data?.prng ? JSON.parse(delta.deltaMessageReply.repliedToMessage.data.prng) : [];
-            if (rmdata) {
-                rmdata.forEach(m => rmentions[m.i] = (delta.deltaMessageReply.repliedToMessage.body || "").substring(m.o, m.o + m.l));
-            }
-
-            callbackToReturn.messageReply = {
-              threadID: (delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.otherUserFbId).toString(),
-              messageID: delta.deltaMessageReply.repliedToMessage.messageMetadata.messageId,
-              senderID: delta.deltaMessageReply.repliedToMessage.messageMetadata.actorFbId.toString(),
-              attachments: delta.deltaMessageReply.repliedToMessage.attachments.map(att => {
-                 try {
-                    var mercury = JSON.parse(att.mercuryJSON);
-                    Object.assign(att, mercury);
-                    return utils._formatAttachment(att);
-                  } catch (ex) {
-                    return { ...att, error: ex, type: "unknown" };
-                  }
-              }),
-              body: delta.deltaMessageReply.repliedToMessage.body || "",
-              isGroup: !!delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId,
-              mentions: rmentions,
-              timestamp: delta.deltaMessageReply.repliedToMessage.messageMetadata.timestamp,
-              participantIDs: (delta.deltaMessageReply.repliedToMessage.participants || []).map(e => e.toString())
-            };
-            try {
-              if (e2ee.isEnabled(ctx) && callbackToReturn.messageReply.isGroup) {
-                const dec2 = e2ee.decrypt(ctx, callbackToReturn.messageReply.threadID, callbackToReturn.messageReply.body);
-                if (dec2 !== null) callbackToReturn.messageReply.body = dec2;
-              }
-            } catch (_) {}
-          }
-          if (ctx.globalOptions.autoMarkDelivery) api.markAsDelivered(callbackToReturn.threadID, callbackToReturn.messageID);
-          if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
-          return globalCallback(null, callbackToReturn);
-        }
-      }
-      return;
-    }
-  }
-
-  if (v.delta.class !== "NewMessage" && !ctx.globalOptions.listenEvents) return;
-  switch (v.delta.class) {
-    case "ReadReceipt":
-      var fmtMsg;
-      try {
-        fmtMsg = utils.formatDeltaReadReceipt(v.delta);
-      } catch (err) {
-        return;
-      }
-      if (fmtMsg) globalCallback(null, fmtMsg);
-      break;
-    case "AdminTextMessage":
-      switch (v.delta.type) {
-        case "instant_game_dynamic_custom_update":
-        case "accept_pending_thread":
-        case "confirm_friend_request":
-        case "shared_album_delete":
-        case "shared_album_addition":
-        case "pin_messages_v2":
-        case "unpin_messages_v2":
-        case "change_thread_theme":
-        case "change_thread_nickname":
-        case "change_thread_icon":
-        case "change_thread_quick_reaction":
-        case "change_thread_admins":
-        case "group_poll":
-        case "joinable_group_link_mode_change":
-        case "magic_words":
-        case "change_thread_approval_mode":
-        case "messenger_call_log":
-        case "participant_joined_group_call":
-        case "rtc_call_log":
-        case "update_vote":
-          var fmtEvent;
-          try {
-            fmtEvent = utils.formatDeltaEvent(v.delta);
-          } catch (err) {
-            return;
-          }
-          if (fmtEvent) globalCallback(null, fmtEvent);
-          break;
-      }
-      break;
-    case "ThreadName":
-    case "ParticipantsAddedToGroupThread":
-    case "ParticipantLeftGroupThread":
-      var fmtEvent2;
-      try {
-        fmtEvent2 = utils.formatDeltaEvent(v.delta);
-      } catch (err) {
-        return;
-      }
-      if (!ctx.globalOptions.selfListen && fmtEvent2 && fmtEvent2.author && fmtEvent2.author.toString() === ctx.userID) return;
-      if (!ctx.loggedIn) return;
-      if (fmtEvent2) globalCallback(null, fmtEvent2);
-      break;
-    case "ForcedFetch":
-      if (!v.delta.threadKey) return;
-      var mid = v.delta.messageId;
-      var tid = v.delta.threadKey.threadFbId;
-      if (mid && tid) {
-        var form = {
-          av: ctx.globalOptions.pageID,
-          queries: JSON.stringify({
-            o0: {
-              doc_id: "2848441488556444",
-              query_params: {
-                thread_and_message_id: {
-                  thread_id: tid.toString(),
-                  message_id: mid
-                }
-              }
-            }
-          })
-        };
-        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-          .then(resData => {
-            if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
-            if (resData[resData.length - 1].successful_results === 0) throw { error: "forcedFetch: no successful_results" };
-            var fetchData = resData[0].o0.data.message;
-            if (utils.getType(fetchData) === "Object") {
-              if (fetchData.__typename === "UserMessage" && fetchData.extensible_attachment) {
-                var event = {
-                  type: "message",
-                  senderID: utils.formatID(fetchData.message_sender.id),
-                  body: fetchData.message.text || "",
-                  threadID: utils.formatID(tid.toString()),
-                  messageID: fetchData.message_id,
-                  attachments: [{
-                    type: "share",
-                    ID: fetchData.extensible_attachment.legacy_attachment_id,
-                    url: fetchData.extensible_attachment.story_attachment.url,
-                    title: fetchData.extensible_attachment.story_attachment.title_with_entities.text,
-                    description: fetchData.extensible_attachment.story_attachment.description ? fetchData.extensible_attachment.story_attachment.description.text : "",
-                    source: fetchData.extensible_attachment.story_attachment.source,
-                    image: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).uri,
-                    width: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).width,
-                    height: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).height,
-                    playable: ((fetchData.extensible_attachment.story_attachment.media || {}).is_playable || false),
-                    duration: ((fetchData.extensible_attachment.story_attachment.media || {}).playable_duration_in_ms || 0)
-                  }],
-                  mentions: {},
-                  timestamp: parseInt(fetchData.timestamp_precise),
-                  isGroup: fetchData.message_sender.id !== tid.toString()
-                };
-                try {
-                  if (e2ee.isEnabled(ctx) && event.isGroup) {
-                    const dec = e2ee.decrypt(ctx, event.threadID, event.body);
-                    if (dec !== null) event.body = dec;
-                  }
-                } catch (_) {}
-                globalCallback(null, event);
-              }
-            }
-          })
-          .catch(err => {});
-      }
-      break;
-  }
-}
-
-module.exports = {
-    parseDelta
-};

package/src/apis/muteThread.js

@@ -1,45 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-
-module.exports = (defaultFuncs, api, ctx) => {
-  return async function muteThread(threadID, muteSeconds, 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 = {
-        thread_fbid: threadID,
-        mute_settings: muteSeconds
-      };
-
-      const res = await defaultFuncs.post(
-        "https://www.facebook.com/ajax/mercury/change_mute_thread.php",
-        ctx.jar,
-        form
-      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-
-      if (res && res.error) {
-        throw res;
-      }
-
-      callback(null, { success: true });
-    } catch (err) {
-      utils.error("muteThread", err);
-      callback(err);
-    }
-
-    return returnPromise;
-  };
-};

package/src/apis/nickname.js

@@ -1,132 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-
-module.exports = function (defaultFuncs, api, ctx) { 
-  /**
-   * Made by Choru Official 
-   * Mqtt
-   * Sets a nickname for a participant in a Facebook thread via MQTT.
-   *
-   * @param {string} nickname The new nickname to set.
-   * @param {string} threadID The ID of the thread.
-   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
-   * @param {Function} [callback] Optional callback function to be invoked upon completion.
-   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
-   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
-   */
-  return function setNickname(nickname, threadID, participantID, callback, initiatorID) {
-    let _callback;
-    let _initiatorID;
-
-    let _resolvePromise;
-    let _rejectPromise;
-    const returnPromise = new Promise((resolve, reject) => {
-        _resolvePromise = resolve;
-        _rejectPromise = reject;
-    });
-
-    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
-        _callback = callback;
-        _initiatorID = initiatorID;
-    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
-        _callback = threadID;
-        threadID = null;
-        _initiatorID = callback;
-    } else if (utils.getType(participantID) === "Function" || utils.getType(participantID) === "AsyncFunction") {
-        _callback = participantID;
-        participantID = ctx.userID;
-        _initiatorID = callback;
-    }
-    else if (utils.getType(callback) === "string") {
-        _initiatorID = callback;
-        _callback = undefined;
-    } else {
-        _callback = undefined;
-        _initiatorID = undefined;
-    }
-
-    if (!_callback) {
-      _callback = function (__err, __data) {
-        if (__err) _rejectPromise(__err);
-        else _resolvePromise(__data);
-      };
-    } else {
-      const originalCallback = _callback;
-      _callback = function(__err, __data) {
-        if (__err) {
-          originalCallback(__err);
-          _rejectPromise(__err);
-        } else {
-          originalCallback(null, __data);
-          _resolvePromise(__data);
-        }
-      };
-    }
-
-    _initiatorID = _initiatorID || ctx.userID;
-
-    threadID = threadID || ctx.threadID;
-    participantID = participantID || ctx.userID;
-
-    if (!threadID) {
-      return _callback(new Error("threadID is required to set a nickname."));
-    }
-    if (typeof nickname !== 'string') {
-      return _callback(new Error("nickname must be a string."));
-    }
-
-    if (!ctx.mqttClient) {
-      return _callback(new Error("Not connected to MQTT"));
-    }
-
-    ctx.wsReqNumber += 1;
-    ctx.wsTaskNumber += 1;
-
-    const queryPayload = {
-      thread_key: threadID.toString(),
-      contact_id: participantID.toString(),
-      nickname: nickname,
-      sync_group: 1,
-    };
-
-    const query = {
-      failure_count: null,
-      label: '44',
-      payload: JSON.stringify(queryPayload),
-      queue_name: 'thread_participant_nickname',
-      task_id: ctx.wsTaskNumber,
-    };
-
-    const context = {
-      app_id: ctx.appID,
-      payload: {
-        epoch_id: parseInt(utils.generateOfflineThreadingID()),
-        tasks: [query],
-        version_id: '24631415369801570',
-      },
-      request_id: ctx.wsReqNumber,
-      type: 3,
-    };
-    context.payload = JSON.stringify(context.payload);
-    
-    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
-      if (err) {
-        return _callback(new Error(`MQTT publish failed for setNickname: ${err.message || err}`));
-      }
-      
-      const nicknameChangeEvent = {
-        type: "thread_nickname_update", 
-        threadID: threadID,
-        participantID: participantID,
-        newNickname: nickname,
-        senderID: _initiatorID,
-        BotID: ctx.userID,
-        timestamp: Date.now(),
-      };
-      _callback(null, nicknameChangeEvent);
-    });
-
-    return returnPromise;
-  };
-};

package/src/apis/notes.js

@@ -1,163 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-
-/**
- * @ChoruOfficial
- * @description A module for interacting with Facebook Messenger Notes. This is not for creating notes on a user's profile page, but rather the temporary status-like notes in Messenger.
- * @param {Object} defaultFuncs The default functions provided by the API wrapper.
- * @param {Object} api The full API object.
- * @param {Object} ctx The context object containing the user's session state (e.g., userID, jar).
- * @returns {Object} An object containing methods to create, delete, recreate, and check notes.
- */
-module.exports = function(defaultFuncs, api, ctx) {
-
-  /**
-   * @callback notesCallback
-   * @param {Error|null} error An error object if the request fails, otherwise null.
-   * @param {Object} [data] The data returned from the API.
-   */
-
-  /**
-   * Checks for the currently active note for the logged-in user.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object representing the current note.
-   */
-  function checkNote(callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
-    const form = {
-      fb_api_caller_class: "RelayModern",
-      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogQuery",
-      variables: JSON.stringify({ scale: 2 }),
-      doc_id: "30899655739648624",
-    };
-
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const currentNote = resData?.data?.viewer?.actor?.msgr_user_rich_status;
-        callback(null, currentNote);
-      })
-      .catch(err => {
-        utils.error("notes.checkNote", err);
-        callback(err);
-      });
-  }
-
-  /**
-   * Creates a new note with the provided text. The note lasts for 24 hours (86400 seconds).
-   * @param {string} text The content of the note.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the note's creation status.
-   */
-  function createNote(text, privacy = "EVERYONE", callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
-    const variables = {
-      input: {
-        client_mutation_id: Math.round(Math.random() * 10).toString(),
-        actor_id: ctx.userID,
-        description: text,
-        duration: 86400,
-        note_type: "TEXT_NOTE",
-        privacy,
-        session_id: utils.getGUID(),
-      },
-    };
-    const form = {
-      fb_api_caller_class: "RelayModern",
-      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogCreationStepContentMutation",
-      variables: JSON.stringify(variables),
-      doc_id: "24060573783603122",
-    };
-
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const status = resData?.data?.xfb_rich_status_create?.status;
-        if (!status) throw new Error("Could not find note status in the server response.");
-        callback(null, status);
-      })
-      .catch(err => {
-        utils.error("notes.createNote", err);
-        callback(err);
-      });
-  }
-
-  /**
-   * Deletes a specific note by its ID.
-   * @param {string} noteID The ID of the note to be deleted.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the deletion.
-   */
-  function deleteNote(noteID, callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
-    const variables = {
-      input: {
-        client_mutation_id: Math.round(Math.random() * 10).toString(),
-        actor_id: ctx.userID,
-        rich_status_id: noteID,
-      },
-    };
-    const form = {
-      fb_api_caller_class: "RelayModern",
-      fb_api_req_friendly_name: "useMWInboxTrayDeleteNoteMutation",
-      variables: JSON.stringify(variables),
-      doc_id: "9532619970198958",
-    };
-
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const deletedStatus = resData?.data?.xfb_rich_status_delete;
-        if (!deletedStatus) throw new Error("Could not find deletion status in the server response.");
-        callback(null, deletedStatus);
-      })
-      .catch(err => {
-        utils.error("notes.deleteNote", err);
-        callback(err);
-      });
-  }
-
-  /**
-   * A convenience function that first deletes an old note and then creates a new one.
-   * @param {string} oldNoteID The ID of the note to delete.
-   * @param {string} newText The text for the new note.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object containing the deletion and creation statuses.
-   */
-  function recreateNote(oldNoteID, newText, callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
-    deleteNote(oldNoteID, (err, deleted) => {
-      if (err) {
-        return callback(err);
-      }
-      createNote(newText, (err, created) => {
-        if (err) {
-          return callback(err);
-        }
-        callback(null, { deleted, created });
-      });
-    });
-  }
-
-  return {
-    create: createNote,
-    delete: deleteNote,
-    recreate: recreateNote,
-    check: checkNote,
-  };
-};