@lazyneoaz/nkxchat 1.0.0

package/src/apis/setMessageReactionMqtt.js

@@ -0,0 +1,61 @@
+
+'use strict';
+
+const utils = require('../utils');
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: Date.now(),
+      message_id: messageID,
+      reaction,
+      actor_id: ctx.userID,
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289
+    };
+
+    const task = {
+      failure_count: null,
+      label: '29',
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(['reaction', messageID]),
+      task_id: ctx.wsTaskNumber
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: '7158486590867448',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    /*if (isCallable(callback)) {
+      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    }*/
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/apis/setPostReaction.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Adds or removes a reaction on a Facebook post (not a Messenger message).
+ *
+ * For reacting to Messenger messages use api.setMessageReaction() instead.
+ *
+ * @param {string}          postID    The Facebook post/object ID.
+ * @param {string|number}   type      Reaction type:
+ *   - Named:  "like" | "heart" | "love" | "haha" | "wow" | "sad" | "angry" | "unlike"
+ *   - Numeric: 0=unlike, 1=like, 2=heart, 4=haha, 3=wow, 7=sad, 8=angry, 16=love
+ * @param {Function}        [callback]
+ * @returns {Promise}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  const REACTION_MAP = {
+    unlike: 0,
+    like:   1,
+    heart:  2,
+    love:   16,
+    haha:   4,
+    wow:    3,
+    sad:    7,
+    angry:  8,
+  };
+
+  return function setPostReaction(postID, type, callback) {
+    let reactionType = type;
+    let cb = callback;
+
+    // Allow omitting type to default to "unlike"
+    if (!cb && (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction")) {
+      cb = type;
+      reactionType = 0;
+    }
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!cb) {
+      cb = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    if (!postID) return cb(new Error("postID is required"));
+
+    // Resolve named type
+    if (utils.getType(reactionType) === "String") {
+      const key = String(reactionType).toLowerCase();
+      if (key in REACTION_MAP) {
+        reactionType = REACTION_MAP[key];
+      } else {
+        return cb(new Error(`Unknown reaction type "${type}". Valid types: ${Object.keys(REACTION_MAP).join(", ")}`));
+      }
+    }
+
+    if (typeof reactionType !== "number") {
+      return cb(new Error("setPostReaction: reaction type must be a string or number"));
+    }
+
+    const feedbackID = Buffer.from(`feedback:${postID}`).toString("base64");
+
+    const form = {
+      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: "CometUFIFeedbackReactMutation",
+      doc_id:    "4769042373179384",
+      variables: JSON.stringify({
+        input: {
+          actor_id:              ctx.userID,
+          feedback_id:           feedbackID,
+          feedback_reaction:     reactionType,
+          feedback_source:       "OBJECT",
+          is_tracking_encrypted: true,
+          tracking:              [],
+          session_id:            utils.getSignatureID() + "-" + Date.now(),
+          client_mutation_id:    Math.floor(Math.random() * 20).toString(),
+        },
+        useDefaultActor: false,
+        scale: 3,
+      }),
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData;
+
+        const fbReact = resData && resData.data && resData.data.feedback_react;
+        const result = {
+          postID,
+          reactionType,
+          success: true,
+          reaction_count: fbReact && fbReact.feedback
+            ? fbReact.feedback.reaction_count
+            : null,
+        };
+
+        cb(null, result);
+      })
+      .catch((err) => {
+        utils.error("setPostReaction", err.message || err);
+        cb(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};

package/src/apis/setThreadTheme.js

@@ -0,0 +1,210 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Sets the visual theme of a Messenger thread.
+ *
+ * Accepts:
+ *   - A numeric theme ID string  ("196241301102133")
+ *   - A color alias              ("blue", "purple", "green", …)
+ *   - A theme name substring     ("Citrus", "Tie-Dye", …) — matched against live theme list
+ *   - An object                  ({ themeId, emoji })
+ *
+ * Strategy: tries the legacy GraphQL batch endpoint first (fastest), then falls
+ * back to the modern Relay mutation, then the MQTT layer.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setThreadTheme(threadID, themeData, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!threadID) {
+      return callback(new Error("threadID is required"));
+    }
+
+    // ── Hardcoded colour aliases (fast path — no API round trip needed) ──────
+    const PALETTE = {
+      blue:    "196241301102133",
+      purple:  "370940413392601",
+      green:   "169463077092846",
+      pink:    "230032715012014",
+      orange:  "175615189761153",
+      red:     "2136751179887052",
+      yellow:  "2058653964378557",
+      teal:    "417639218648241",
+      black:   "539927563794799",
+      white:   "2873642392710980",
+      default: "196241301102133",
+    };
+
+    (async function worker() {
+      try {
+        const now = Date.now();
+        let availableThemes = [];
+
+        // Attempt to fetch the live theme list for name-based resolution
+        try {
+          const themeQueryForm = {
+            av:  ctx.userID,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            dpr: 1,
+            fb_dtsg:  ctx.fb_dtsg,
+            jazoest:  ctx.jazoest,
+            lsd:      ctx.lsd || ctx.fb_dtsg,
+            fb_api_caller_class:      "RelayModern",
+            fb_api_req_friendly_name: "MWPThreadThemeQuery_AllThemesQuery",
+            variables:        JSON.stringify({ version: "default" }),
+            server_timestamps: true,
+            doc_id:           "24474714052117636",
+          };
+
+          const themeRes = await defaultFuncs
+            .post("https://www.facebook.com/api/graphql/", ctx.jar, themeQueryForm)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+          if (themeRes && themeRes.data && themeRes.data.messenger_thread_themes) {
+            availableThemes = themeRes.data.messenger_thread_themes;
+          }
+        } catch (_) {
+          utils.warn("setThreadTheme", "Could not fetch live theme list; using aliases only");
+        }
+
+        // ── Resolve the theme ID ──────────────────────────────────────────
+        let chosenThemeId = null;
+        let chosenEmoji   = "👍";
+
+        if (typeof themeData === "string") {
+          const s = themeData.trim();
+
+          if (/^\d+$/.test(s)) {
+            chosenThemeId = s;
+          } else {
+            // Try live list first (name substring match)
+            const norm = s.toLowerCase();
+            const found = availableThemes.find(t =>
+              (t.accessibility_label || '').toLowerCase().includes(norm) ||
+              (t.name || '').toLowerCase().includes(norm)
+            );
+            if (found) {
+              chosenThemeId = found.id;
+            } else {
+              chosenThemeId = PALETTE[norm] || PALETTE.default;
+            }
+          }
+        } else if (typeof themeData === "object" && themeData !== null) {
+          chosenThemeId = themeData.themeId || themeData.theme_id || themeData.id || null;
+          chosenEmoji   = themeData.emoji || themeData.customEmoji || chosenEmoji;
+        }
+
+        if (!chosenThemeId) chosenThemeId = PALETTE.default;
+
+        // ── Strategy 1: legacy GraphQL batch ─────────────────────────────
+        try {
+          const legacyBody = {
+            dpr: 1,
+            queries: JSON.stringify({
+              o0: {
+                doc_id: "1727493033983591",
+                query_params: {
+                  data: {
+                    actor_id:           ctx.userID,
+                    client_mutation_id: "0",
+                    source:             "SETTINGS",
+                    theme_id:           chosenThemeId,
+                    thread_id:          threadID,
+                  },
+                },
+              },
+            }),
+          };
+
+          const legacyResp = await defaultFuncs
+            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, legacyBody)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+          if (legacyResp && !(legacyResp[0] && legacyResp[0].o0 && legacyResp[0].o0.errors)) {
+            return callback(null, {
+              threadID,
+              themeId:     chosenThemeId,
+              customEmoji: chosenEmoji,
+              timestamp:   now,
+              success:     true,
+              method:      "legacy",
+            });
+          }
+        } catch (_) {
+          utils.warn("setThreadTheme", "Legacy batch approach failed; trying Relay mutation");
+        }
+
+        // ── Strategy 2: Relay Modern mutation ────────────────────────────
+        const mutationBody = {
+          av:     ctx.userID,
+          __user: ctx.userID,
+          __a:    1,
+          __req:  utils.getSignatureID(),
+          dpr:    1,
+          fb_dtsg:  ctx.fb_dtsg,
+          jazoest:  ctx.jazoest,
+          lsd:      ctx.lsd || ctx.fb_dtsg,
+          fb_api_caller_class:      "RelayModern",
+          fb_api_req_friendly_name: "MessengerThreadThemeUpdateMutation",
+          variables: JSON.stringify({
+            input: {
+              actor_id:          ctx.userID,
+              client_mutation_id: Math.floor(Math.random() * 10000).toString(),
+              source:             "SETTINGS",
+              thread_id:          String(threadID),
+              theme_id:           String(chosenThemeId),
+              custom_emoji:       chosenEmoji,
+            },
+          }),
+          server_timestamps: true,
+          doc_id: "9734829906576883",
+        };
+
+        const gqlResult = await defaultFuncs
+          .post("https://www.facebook.com/api/graphql/", ctx.jar, mutationBody)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (gqlResult && gqlResult.errors && gqlResult.errors.length > 0) {
+          throw new Error("GraphQL Error: " + JSON.stringify(gqlResult.errors));
+        }
+
+        // ── Strategy 3: MQTT fallback ─────────────────────────────────────
+        if (ctx.mqttClient) {
+          try {
+            await api.setThreadThemeMqtt(threadID, chosenThemeId);
+          } catch (_) {}
+        }
+
+        return callback(null, {
+          threadID,
+          themeId:     chosenThemeId,
+          customEmoji: chosenEmoji,
+          timestamp:   now,
+          success:     true,
+          method:      "graphql",
+        });
+
+      } catch (err) {
+        utils.error("setThreadTheme", err.message || err);
+        return callback(err instanceof Error ? err : new Error(String(err.message || err)));
+      }
+    })();
+
+    return promise;
+  };
+};

package/src/apis/setThreadThemeMqtt.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setThreadThemeMqtt(threadID, themeFBID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    let baseTaskNumber = ++ctx.wsTaskNumber;
+
+    const makeTask = (label, queueName, extraPayload = {}) => ({
+      failure_count: null,
+      label: String(label),
+      payload: JSON.stringify({
+        thread_key: threadID,
+        theme_fbid: themeFBID,
+        sync_group: 1,
+        ...extraPayload,
+      }),
+      queue_name: typeof queueName === 'string' ? queueName : JSON.stringify(queueName),
+      task_id: baseTaskNumber++,
+    });
+
+    const messages = [
+      {
+        label: 1013,
+        queue: ['ai_generated_theme', String(threadID)],
+      },
+      {
+        label: 1037,
+        queue: ['msgr_custom_thread_theme', String(threadID)],
+      },
+      {
+        label: 1028,
+        queue: ['thread_theme_writer', String(threadID)],
+      },
+      {
+        label: 43,
+        queue: 'thread_theme',
+        extra: { source: null, payload: null },
+      },
+    ].map(({ label, queue, extra }) => {
+      ctx.wsReqNumber += 1;
+      return {
+        app_id: '772021112871879',
+        payload: JSON.stringify({
+          epoch_id: parseInt(utils.generateOfflineThreadingID()),
+          tasks: [makeTask(label, queue, extra)],
+          version_id: '24227364673632991',
+        }),
+        request_id: ctx.wsReqNumber,
+        type: 3,
+      };
+    });
+
+    // Return promise if no callback provided
+    if (!callback) {
+      return new Promise((resolve, reject) => {
+        try {
+          messages.forEach((msg, idx) => {
+            ctx.mqttClient.publish(
+              '/ls_req',
+              JSON.stringify(msg),
+              { qos: 1, retain: false },
+              idx === messages.length - 1 ? (err) => {
+                if (err) reject(err);
+                else resolve();
+              } : undefined
+            );
+          });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    }
+
+    // Callback mode
+    try {
+      messages.forEach((msg, idx) => {
+        ctx.mqttClient.publish(
+          '/ls_req',
+          JSON.stringify(msg),
+          { qos: 1, retain: false },
+          idx === messages.length - 1 ? callback : undefined
+        );
+      });
+    } catch (err) {
+      callback(err);
+    }
+  };
+};

package/src/apis/setTitle.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/**
+ * Changes the title of a group thread.
+ *
+ * This is an alias for `api.gcname()` using the same MQTT implementation,
+ * provided for API compatibility with standard FCA libraries.
+ *
+ * @example
+ * await api.setTitle("My Group Name", threadID);
+ *
+ * @param {string}   newTitle   The new name for the group.
+ * @param {string}   threadID   The group thread ID.
+ * @param {Function} [callback]
+ * @returns {Promise}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setTitle(newTitle, threadID, callback) {
+    if (!api.gcname || typeof api.gcname !== "function") {
+      const err = new Error("setTitle requires the gcname module to be loaded.");
+      if (callback) return callback(err);
+      return Promise.reject(err);
+    }
+    return api.gcname(newTitle, threadID, callback);
+  };
+};

package/src/apis/share.js

@@ -0,0 +1,106 @@
+"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 resolveFunc, rejectFunc;
+        const returnPromise = new Promise((resolve, reject) => {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        
+        const cb = (err, data) => {
+            if (callback) callback(err, data);
+            if (err) return rejectFunc(err);
+            resolveFunc(data);
+        };
+        if (!postID) {
+            cb({ error: "A postID is required to generate a preview." });
+            return returnPromise;
+        }
+
+        const variables = {
+            shareable_id: postID.toString(),
+            scale: 3,
+        };
+
+        // Use configurable doc_id or default (may be outdated)
+        // To update: 
+        // 1. Open Facebook Messenger in browser
+        // 2. Open DevTools (F12) → Network tab → Filter by "graphql"
+        // 3. Trigger a share/preview action
+        // 4. Look for CometXMAProxyShareablePreviewQuery request
+        // 5. Copy the doc_id value from the request payload
+        // 6. Set ctx.options.sharePreviewDocId = 'NEW_DOC_ID' when logging in
+        //
+        // Known doc_ids (may expire):
+        // - 28939050904374351 (expired as of Nov 2024)
+        const docId = ctx.options?.sharePreviewDocId || '28939050904374351';
+
+        const form = {
+            fb_api_caller_class: 'RelayModern',
+            fb_api_req_friendly_name: 'CometXMAProxyShareablePreviewQuery',
+            variables: JSON.stringify(variables),
+            doc_id: docId
+        };
+
+        try {
+            const resData = await defaultFuncs
+                .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            
+            // Check for persisted query not found error (case-insensitive)
+            if (resData?.errors) {
+                const persistedQueryError = resData.errors.find(e => {
+                    const msg = (e.message || '').toLowerCase();
+                    return msg.includes('persistedquerynotfound') || 
+                           msg.includes('document') && msg.includes('not found') ||
+                           msg.includes('persisted query');
+                });
+                if (persistedQueryError) {
+                    const error = {
+                        error: "Facebook GraphQL doc_id expired. Please update ctx.options.sharePreviewDocId",
+                        details: "Capture the current doc_id from Messenger web traffic (inspect CometXMAProxyShareablePreviewQuery request)",
+                        currentDocId: docId,
+                        fbError: persistedQueryError.message
+                    };
+                    utils.error("getPostPreview", error);
+                    cb(error);
+                    return returnPromise;
+                }
+            }
+            
+            const result = formatPreviewResult(resData);
+            cb(null, result);
+            return returnPromise;
+        } catch (err) {
+            // Add helpful context for common failure modes
+            if (err.message?.includes('UNHANDLED_REJECTION') || err.message?.includes('not found')) {
+                err.hint = "The GraphQL doc_id may be outdated. Set ctx.options.sharePreviewDocId with current value from Messenger traffic.";
+            }
+            utils.error("getPostPreview", err);
+            cb(err);
+            return returnPromise;
+        }
+    };
+};

package/src/apis/shareContact.js

@@ -0,0 +1,66 @@
+/* eslint-disable linebreak-style */
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @module shareContact
+ * @param {Object} defaultFuncs - The default functions provided by the API.
+ * @param {Object} api - The full API object.
+ * @param {Object} ctx - The context object.
+ * @returns {function(text: string, senderID: string, threadID: string, callback: Function): void} - A function to share a contact.
+ */
+module.exports = function(defaultFuncs, api, ctx) {
+  /**
+   * Shares a user's contact information into a specific thread via MQTT.
+   * @param {string} [text] - An optional message to send along with the contact card.
+   * @param {string} senderID - The Facebook user ID of the contact you want to share.
+   * @param {string} threadID - The ID of the thread where the contact will be shared.
+   * @param {Function} [callback] - An optional callback function to be executed.
+   */
+  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',
+      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 });
+  };
+};