fca-neokex-fix 1.0.1

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/setThreadTheme.js

@@ -0,0 +1,260 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+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({ error: "threadID is required" });
+    }
+
+    (async function worker() {
+      try {
+        const now = Date.now();
+
+        // Try to fetch bootloader
+        try {
+          const bootParams = new URLSearchParams({
+            modules: "LSUpdateThreadTheme,LSUpdateThreadCustomEmoji,LSUpdateThreadThemePayloadCacheKey",
+            __aaid: 0,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            __hs: "20352.HYP:comet_pkg.2.1...0",
+            dpr: 1,
+            __ccg: "EXCELLENT",
+            __rev: "1027396270",
+            __s: utils.getSignatureID(),
+            __hsi: "7552524636527201016",
+            __comet_req: 15,
+            fb_dtsg_ag: ctx.fb_dtsg,
+            jazoest: ctx.jazoest,
+            __spin_r: "1027396270",
+            __spin_b: "trunk",
+            __spin_t: now,
+            __crn: "comet.fbweb.MWInboxHomeRoute"
+          });
+
+          await defaultFuncs.get(
+            "https://www.facebook.com/ajax/bootloader-endpoint/?" + bootParams.toString(),
+            ctx.jar
+          ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        } catch (bootErr) {
+          log.warn("setThreadTheme", "bootloader fetch failed, continuing");
+        }
+
+        let availableThemes = [];
+        try {
+          const themeQueryForm = {
+            av: ctx.userID,
+            __aaid: 0,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            __hs: "20352.HYP:comet_pkg.2.1...0",
+            dpr: 1,
+            __ccg: "EXCELLENT",
+            __rev: "1027396270",
+            __s: utils.getSignatureID(),
+            __hsi: "7552524636527201016",
+            __comet_req: 15,
+            fb_dtsg: ctx.fb_dtsg,
+            jazoest: ctx.jazoest,
+            lsd: ctx.fb_dtsg,
+            __spin_r: "1027396270",
+            __spin_b: "trunk",
+            __spin_t: now,
+            __crn: "comet.fbweb.MWInboxHomeRoute",
+            qpl_active_flow_ids: "25308101",
+            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 (fetchErr) {
+          log.warn("setThreadTheme", "Could not fetch available themes, proceeding without list");
+        }
+
+        let chosenThemeId = null;
+        let chosenEmoji = "👍";
+
+        if (typeof themeData === "string") {
+          const s = themeData.trim();
+
+          if (/^[0-9]+$/.test(s)) {
+            chosenThemeId = s;
+          } else {
+            const found = (availableThemes || []).find(function (t) {
+              return (
+                t.accessibility_label &&
+                t.accessibility_label.toLowerCase().includes(s.toLowerCase())
+              );
+            });
+            if (found) {
+              chosenThemeId = found.id;
+            } else {
+              const palette = {
+                blue: "196241301102133",
+                purple: "370940413392601",
+                green: "169463077092846",
+                pink: "230032715012014",
+                orange: "175615189761153",
+                red: "2136751179887052",
+                yellow: "2058653964378557",
+                teal: "417639218648241",
+                black: "539927563794799",
+                white: "2873642392710980",
+                default: "196241301102133"
+              };
+              chosenThemeId = palette[s.toLowerCase()] || 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 = "196241301102133";
+        }
+
+        // Try legacy approach first
+        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]?.o0?.errors) {
+            return callback(null, {
+              threadID: threadID,
+              themeId: chosenThemeId,
+              customEmoji: chosenEmoji,
+              timestamp: now,
+              success: true,
+              method: "legacy",
+              availableThemes: availableThemes.length > 0
+                ? availableThemes.map(function (t) {
+                    return { id: t.id, name: t.accessibility_label, description: t.description };
+                  })
+                : null
+            });
+          }
+        } catch (legacyErr) {
+          log.warn("setThreadTheme", "Legacy approach failed; falling back to GraphQL mutation");
+        }
+
+        // Fall back to GraphQL mutation
+        const mutationBody = {
+          av: ctx.userID,
+          __aaid: 0,
+          __user: ctx.userID,
+          __a: 1,
+          __req: utils.getSignatureID(),
+          __hs: "20352.HYP:comet_pkg.2.1...0",
+          dpr: 1,
+          __ccg: "EXCELLENT",
+          __rev: "1027396270",
+          __s: utils.getSignatureID(),
+          __hsi: "7552524636527201016",
+          __comet_req: 15,
+          fb_dtsg: ctx.fb_dtsg,
+          jazoest: ctx.jazoest,
+          lsd: ctx.fb_dtsg,
+          __spin_r: "1027396270",
+          __spin_b: "trunk",
+          __spin_t: now,
+          __crn: "comet.fbweb.MWInboxHomeRoute",
+          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: threadID.toString(),
+              theme_id: chosenThemeId.toString(),
+              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));
+        }
+
+        if (gqlResult && gqlResult.data && gqlResult.data.messenger_thread_theme_update) {
+          const updatePayload = gqlResult.data.messenger_thread_theme_update;
+          if (updatePayload.errors && updatePayload.errors.length > 0) {
+            throw new Error("Theme Update Error: " + JSON.stringify(updatePayload.errors));
+          }
+        }
+
+        return callback(null, {
+          threadID: threadID,
+          themeId: chosenThemeId,
+          customEmoji: chosenEmoji,
+          timestamp: now,
+          success: true,
+          method: "graphql",
+          availableThemes: availableThemes.length > 0
+            ? availableThemes.map(function (t) {
+                return { id: t.id, name: t.accessibility_label, description: t.description };
+              })
+            : null
+        });
+      } catch (err) {
+        log.error("setThreadTheme", err);
+        return callback(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/share.js

@@ -0,0 +1,107 @@
+"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)
+        // - Check ws3-fca or @dongdev packages for potential updates
+        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 });
+  };
+};