@lazyneoaz/nkxchat 1.0.0

package/src/apis/emoji.js

@@ -0,0 +1,124 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets the custom emoji for a specific Facebook thread via MQTT.
+   *
+   * @param {string} emoji The emoji character to set as the custom emoji (e.g., "👍", "❤️").
+   * @param {string} threadID The ID of the thread where the emoji will be set.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the emoji 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 emoji(emoji, threadID, 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(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;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set an emoji."));
+    }
+    if (!emoji) {
+      return _callback(new Error("An emoji character is required."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      custom_emoji: emoji,
+      avatar_sticker_instruction_key_id: null,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '100003',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_quick_reaction',
+      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 emoji: ${err.message || err}`));
+      }
+      
+      const emojiChangeEvent = {
+        type: "thread_emoji_update",
+        threadID: threadID,
+        newEmoji: emoji,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, emojiChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/apis/enableAutoSaveAppState.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const fs   = require("fs");
+const path = require("path");
+
+/**
+ * Enables automatic periodic saving of the current appState (session cookies)
+ * to a JSON file. Returns a `disable()` function to cancel auto-saving.
+ *
+ * @example
+ * const disable = api.enableAutoSaveAppState({ filePath: "./appstate.json" });
+ * // Later:
+ * disable();
+ *
+ * @param {object}  [options]
+ * @param {string}  [options.filePath="./appstate.json"]  Path to save the appState JSON.
+ * @param {number}  [options.interval=600000]              Save interval in ms (default: 10 min).
+ * @param {boolean} [options.saveOnLogin=true]             Save once immediately on call.
+ * @returns {Function}  `disable()` — stops the auto-save timer.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function enableAutoSaveAppState(options) {
+    options = options || {};
+    const filePath   = options.filePath  || path.join(process.cwd(), "appstate.json");
+    const interval   = options.interval  || 10 * 60 * 1000;
+    const saveOnLogin = options.saveOnLogin !== false;
+
+    function saveAppState() {
+      try {
+        const appState = api.getAppState ? api.getAppState() : null;
+        if (!appState || (Array.isArray(appState) && appState.length === 0)) {
+          return;
+        }
+        const payload = Array.isArray(appState) ? appState : (appState.appState || appState);
+        fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+      } catch (err) {
+        // Silently ignore write errors (e.g. read-only FS in some environments)
+      }
+    }
+
+    let immediateTimer = null;
+    if (saveOnLogin) {
+      immediateTimer = setTimeout(() => {
+        saveAppState();
+        immediateTimer = null;
+      }, 2000);
+    }
+
+    const timerId = setInterval(saveAppState, interval);
+
+    // Track timers on ctx so they can be cleaned up on logout
+    if (!ctx._autoSaveIntervals) ctx._autoSaveIntervals = [];
+    ctx._autoSaveIntervals.push(timerId);
+
+    function disable() {
+      if (immediateTimer) {
+        clearTimeout(immediateTimer);
+        immediateTimer = null;
+      }
+      clearInterval(timerId);
+      if (ctx._autoSaveIntervals) {
+        const i = ctx._autoSaveIntervals.indexOf(timerId);
+        if (i !== -1) ctx._autoSaveIntervals.splice(i, 1);
+      }
+    }
+
+    return disable;
+  };
+};

package/src/apis/fetchThemeData.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Fetches detailed color data for a single theme by its numeric ID.
+ * Uses the MWPThreadThemeProviderQuery GraphQL endpoint.
+ *
+ * @param {string} themeID   Numeric theme ID (e.g. "196241301102133")
+ * @param {Function} [callback]
+ * @returns {Promise<ThemeData>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function fetchThemeData(themeID, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+
+    const done = callback || function (err, data) {
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (!themeID) {
+      done(new Error("Theme ID is a required parameter"));
+      return promise;
+    }
+
+    const payload = {
+      av:              ctx.userID,
+      __user:          ctx.userID,
+      __a:             1,
+      __req:           utils.getSignatureID(),
+      fb_dtsg:         ctx.fb_dtsg,
+      lsd:             ctx.lsd || ctx.fb_dtsg,
+      jazoest:         ctx.jazoest,
+      fb_api_caller_class:       "RelayModern",
+      fb_api_req_friendly_name:  "MWPThreadThemeProviderQuery",
+      variables:       JSON.stringify({ id: String(themeID) }),
+      server_timestamps: true,
+      doc_id:          "9734829906576883",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, payload)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(async (res) => {
+        if (res.errors) throw new Error(JSON.stringify(res.errors));
+
+        const data = res && res.data && res.data.messenger_thread_theme;
+        if (!data) throw new Error("Theme data could not be located in the response");
+
+        const gradientColors  = data.gradient_colors || (data.fallback_color ? [data.fallback_color] : []);
+        const bgGradient      = data.background_gradient_colors || gradientColors;
+        const inboundGradient = data.inbound_message_gradient_colors || gradientColors;
+
+        const output = {
+          id:                             data.id,
+          name:                           data.accessibility_label || data.name || '',
+          description:                    data.description || '',
+
+          // ── Colors ─────────────────────────────────────────────
+          primary_color:                  gradientColors[0] || data.fallback_color || null,
+          fallback_color:                 data.fallback_color                     || null,
+          gradient_colors:                gradientColors,
+          background_gradient_colors:     bgGradient,
+          inbound_message_gradient_colors: inboundGradient,
+
+          message_text_color:             data.message_text_color             || null,
+          inbound_message_text_color:     data.inbound_message_text_color     || null,
+          composer_background_color:      data.composer_background_color      || null,
+          composer_input_background_color:data.composer_input_background_color|| null,
+          composer_tint_color:            data.composer_tint_color            || null,
+          title_bar_background_color:     data.title_bar_background_color     || null,
+          title_bar_text_color:           data.title_bar_text_color           || null,
+          title_bar_button_tint_color:    data.title_bar_button_tint_color    || null,
+          title_bar_attribution_color:    data.title_bar_attribution_color    || null,
+          primary_button_background_color:data.primary_button_background_color|| null,
+          hot_like_color:                 data.hot_like_color                 || null,
+          reaction_pill_background_color: data.reaction_pill_background_color || null,
+          secondary_text_color:           data.secondary_text_color           || null,
+          tertiary_text_color:            data.tertiary_text_color            || null,
+          app_color_mode:                 data.app_color_mode                 || null,
+
+          // ── Assets ─────────────────────────────────────────────
+          backgroundImage: data.background_asset ? (data.background_asset.image || {}).uri || null : null,
+          iconImage:       data.icon_asset       ? (data.icon_asset.image || {}).uri       || null : null,
+
+          // ── Alternatives (dark mode, etc.) ──────────────────────
+          alternative_themes: Array.isArray(data.alternative_themes)
+            ? data.alternative_themes.map(a => ({
+                id:             a.id,
+                name:           a.accessibility_label || a.name || '',
+                backgroundImage: a.background_asset ? (a.background_asset.image || {}).uri || null : null,
+                iconImage:       a.icon_asset        ? (a.icon_asset.image || {}).uri        || null : null,
+                gradient_colors: a.gradient_colors || [],
+                fallback_color:  a.fallback_color   || null,
+              }))
+            : [],
+        };
+
+        done(null, output);
+      })
+      .catch((err) => {
+        utils.error("fetchThemeData", err.message || err);
+        done(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};

package/src/apis/follow.js

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * Author @YanMaglinte
+ * https://github.com/YANDEVA
+ * * Example:
+ * api.follow("100090794779367", true);
+ * jsdocs @ChoruOfficial
+ */
+ 
+/**
+ * @param {object} defaultFuncs The default functions for making API requests.
+ * @param {object} api The full API object.
+ * @param {object} ctx The context object.
+ * @returns {function(senderID: string, boolean: boolean, callback?: (err: any, data?: any) => void): void} The follow function.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Follows or unfollows a user on Facebook.
+   * @param {string} senderID The ID of the user to follow or unfollow.
+   * @param {boolean} boolean Set to `true` to follow the user, `false` to unfollow.
+   * @param {(err: any, data?: any) => void} [callback] An optional callback function.
+   */
+  return function follow(senderID, boolean, callback) {
+    let form;
+    if (boolean) {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserFollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,via_cold_start,1717249218695,723451,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            subscribee_id: senderID,
+            tracking: null,
+            actor_id: ctx.userID,
+            client_mutation_id: "1",
+          },
+          scale: 1,
+        }),
+      };
+    } else {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserUnfollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          action_render_location: "WWW_COMET_FRIEND_MENU",
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,tap_search_bar,1717294006136,602597,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            tracking: null,
+            unsubscribee_id: senderID,
+            actor_id: ctx.userID,
+            client_mutation_id: "10",
+          },
+          scale: 1,
+        }),
+      };
+    }
+
+    api.httpPost("https://www.facebook.com/api/graphql/", form, (err, data) => {
+      if (err) {
+        if (typeof callback === "function") {
+          callback(err);
+        }
+      } else {
+        if (typeof callback === "function") {
+          callback(null, data);
+        }
+      }
+    });
+  };
+};

package/src/apis/forwardAttachment.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Forwards one or more attachment IDs to a thread via MQTT.
+ *
+ * Attachment IDs can be obtained from api.uploadAttachment() or from the
+ * attachments field of a received message event.
+ *
+ * @example
+ * // Forward a photo attachment to another thread
+ * await api.forwardAttachment(["1234567890"], targetThreadID);
+ *
+ * @param {string|string[]} attachmentIDs   One or more Facebook attachment IDs.
+ * @param {string}          threadID        Target thread to send the attachment(s) to.
+ * @param {string}          [body]          Optional text body to accompany the attachment.
+ * @param {Function}        [callback]
+ * @returns {Promise<{ messageID, threadID }>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function forwardAttachment(attachmentIDs, threadID, body, callback) {
+    // Allow omitting body
+    if (typeof body === "function") {
+      callback = body;
+      body     = "";
+    }
+    body = body || "";
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!callback) {
+      callback = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    if (!attachmentIDs) return callback(new Error("attachmentIDs is required"));
+    if (!threadID)      return callback(new Error("threadID is required"));
+
+    const ids = Array.isArray(attachmentIDs) ? attachmentIDs : [attachmentIDs];
+
+    // ── Try MQTT first (preferred) ────────────────────────────────────────
+    if (ctx.mqttClient) {
+      const otid      = utils.generateOfflineThreadingID();
+      const epoch_id  = utils.generateOfflineThreadingID();
+      const timestamp = Date.now();
+      const tid       = String(threadID);
+      const reqID     = ++ctx.wsReqNumber;
+
+      const sendPayload = {
+        thread_id:             tid,
+        otid:                  otid.toString(),
+        source:                2097153,
+        send_type:             3,          // attachment
+        sync_group:            1,
+        mark_thread_read:      1,
+        text:                  body || null,
+        initiating_source:     0,
+        skip_url_preview_gen:  0,
+        attachment_fbids:      ids,
+      };
+
+      const content = {
+        app_id:  "2220391788200892",
+        payload: JSON.stringify({
+          tasks: [{
+            label:        "46",
+            payload:      JSON.stringify(sendPayload),
+            queue_name:   tid,
+            task_id:      ++ctx.wsTaskNumber,
+            failure_count: null,
+          }],
+          epoch_id,
+          version_id:    "6120284488008082",
+          data_trace_id: null,
+        }),
+        request_id: reqID,
+        type: 3,
+      };
+
+      let done = false;
+      const timer = setTimeout(() => {
+        if (done) return;
+        done = true;
+        ctx.mqttClient.removeListener("message", onMsg);
+        callback({ error: "Timeout waiting for MQTT ACK" });
+      }, 15000);
+
+      const onMsg = (topic, raw) => {
+        if (topic !== "/ls_resp") return;
+        let parsed;
+        try { parsed = JSON.parse(raw.toString()); parsed.payload = JSON.parse(parsed.payload); } catch { return; }
+        if (parsed.request_id !== reqID || done) return;
+        done = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener("message", onMsg);
+        callback(null, { threadID, messageID: otid.toString(), timestamp, method: "mqtt" });
+      };
+
+      ctx.mqttClient.on("message", onMsg);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+        if (err && !done) {
+          done = true;
+          clearTimeout(timer);
+          ctx.mqttClient.removeListener("message", onMsg);
+          callback(err);
+        }
+      });
+
+      return promise;
+    }
+
+    // ── HTTP fallback ─────────────────────────────────────────────────────
+    const messageAndOTID = utils.generateOfflineThreadingID();
+    const 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:           true,
+      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:                 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:       true,
+      signatureID:          utils.getSignatureID(),
+      thread_fbid:          String(threadID),
+    };
+
+    // Add attachment IDs to form
+    ids.forEach((id, i) => {
+      form[`image_ids[${i}]`] = id;
+    });
+
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/send/", ctx.jar, form, { ...ctx, requestThreadID: String(threadID) })
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (!resData) throw new Error("Empty response from messaging/send");
+        if (resData.error) throw new Error(JSON.stringify(resData));
+
+        const actions = (resData.payload && resData.payload.actions) || [];
+        const msgInfo = actions.reduce((p, v) => ({
+          threadID:  v.thread_fbid  || p.threadID,
+          messageID: v.message_id   || p.messageID,
+          timestamp: v.timestamp    || p.timestamp,
+        }), { threadID, messageID: messageAndOTID, timestamp: Date.now() });
+
+        callback(null, { ...msgInfo, method: "http" });
+      })
+      .catch((err) => {
+        utils.error("forwardAttachment", err.message || err);
+        callback(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};

package/src/apis/forwardMessage.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function forwardMessage(messageID, threadIDs, 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 (!Array.isArray(threadIDs)) {
+        threadIDs = [threadIDs];
+      }
+
+      const form = {
+        message_id: messageID
+      };
+      
+      threadIDs.forEach(id => {
+        form[`recipient_ids[${id}]`] = id;
+      });
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/forward_message.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true, forwardedTo: threadIDs });
+    } catch (err) {
+      utils.error("forwardMessage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};