fca-neokex-fix 1.0.1

package/src/apis/pinMessage.js

@@ -0,0 +1,141 @@
+"use strict";
+
+const utils = require('../utils'); 
+const fs = require("fs");
+const path = require("path");
+const _ = require("lodash");
+const deepdash = require("deepdash");
+const { JSONPath } = require("jsonpath-plus");
+
+deepdash(_);
+
+/**
+ * Extract and save the full lightspeed_web_request object from thread data.
+ * Also search for specific pinned message commands.
+ * @param {Object} allJsonData - Raw JSON response from Facebook.
+ * @returns {Object|null} The full lightspeed_web_request object or null.
+ */
+function extractAndSearchLightspeedRequest(allJsonData) {
+  const outputFile = path.join(__dirname, "lightspeed_web_request.json");
+
+  const lightReq = _.get(allJsonData, "__bbox.result.data.viewer.lightspeed_web_request");
+  if (!lightReq) {
+    utils.warn("pin.js: lightspeed_web_request not found.");
+    return null;
+  }
+
+
+  try {
+    fs.writeFileSync(outputFile, JSON.stringify(lightReq, null, 2), "utf8");
+    utils.log(`pin.js: Saved lightspeed_web_request to ${outputFile}`);
+  } catch (err) {
+    utils.error("pin.js: Failed to write lightspeed_web_request.json", err);
+  }
+
+
+  try {
+    const matches = JSONPath({
+      path: `$..[?(@ === "setPinnedMessage" || @ === "deleteThenInsertMessage")]`,
+      json: lightReq
+    });
+
+    utils.log(`pin.js: Found ${matches.length} matching command(s).`);
+    matches.forEach((match, idx) => {
+      console.log(`📌 Match ${idx + 1}:`, match);
+    });
+  } catch (err) {
+    utils.error("pin.js: JSONPath search failed.", err);
+  }
+
+  return lightReq;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function pin(action, threadID, messageID) {
+    if (action === "list") {
+      if (!threadID) throw new Error('Action "list" requires threadID.');
+
+      try {
+        const url = `https://www.facebook.com/messages/t/${threadID}/`;
+        const allJsonData = await utils.json(url, ctx.jar, null, ctx.globalOptions, ctx);
+
+
+        const lightReq = extractAndSearchLightspeedRequest(allJsonData);
+        if (!lightReq || !lightReq.pin_status) {
+          utils.warn("pin.js: No pinned messages found or pin_status missing.");
+          return [];
+        }
+        return lightReq;
+      } catch (err) {
+        utils.error(`pin.js: Failed to process "list" for thread ${threadID}`, err);
+        throw err;
+      }
+    }
+
+    if (!ctx.mqttClient) throw new Error("MQTT not connected.");
+    if (!threadID || !messageID) throw new Error(`"${action}" requires threadID and messageID.`);
+
+    const epoch_id = parseInt(utils.generateOfflineThreadingID());
+    const version_id = "9523201934447612";
+    const app_id = "2220391788200892";
+
+    const createMqttRequest = (tasks, increment = 0) => ({
+      app_id,
+      payload: JSON.stringify({ epoch_id: epoch_id + increment, tasks, version_id }),
+      request_id: (ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1),
+      type: 3
+    });
+
+    const publishMqtt = (content) =>
+      new Promise((resolve, reject) => {
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+          if (err) reject(err);
+          else resolve({ success: true, request_id: content.request_id });
+        });
+      });
+
+    if (action === "pin") {
+      const pinTask = {
+        label: "430",
+        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
+        queue_name: `pin_msg_v2_${threadID}`,
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const setSearchTask = {
+        label: "751",
+        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 1 }),
+        queue_name: "set_pinned_message_search",
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const req1 = createMqttRequest([pinTask], 0);
+      const req2 = createMqttRequest([setSearchTask], 1);
+      return Promise.all([publishMqtt(req1), publishMqtt(req2)]);
+    }
+
+    if (action === "unpin") {
+      const setSearchTask1 = {
+        label: "751",
+        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
+        queue_name: "set_pinned_message_search",
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const unpinTask = {
+        label: "431",
+        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
+        queue_name: `unpin_msg_v2_${threadID}`,
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const setSearchTask2 = {
+        label: "751",
+        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
+        queue_name: "set_pinned_message_search",
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      await publishMqtt(createMqttRequest([setSearchTask1], 0));
+      await publishMqtt(createMqttRequest([unpinTask], 1));
+      return publishMqtt(createMqttRequest([setSearchTask2], 2));
+    }
+
+    throw new Error(`Invalid action: "${action}". Use "pin", "unpin", or "list".`);
+  };
+};

package/src/apis/produceMetaTheme.js

@@ -0,0 +1,180 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function produceMetaTheme(prompt, opts, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof opts === "function") {
+      callback = opts;
+      opts = {};
+    }
+    opts = opts || {};
+    if (typeof callback !== "function") {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!prompt || typeof prompt !== "string") {
+      callback({ error: "Prompt is required and must be a string" });
+      return promise;
+    }
+
+    const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+    const randId = () => Math.floor(Math.random() * 10).toString();
+
+    const makeInput = () => {
+      const desired = ("numThemes" in opts) ? Number(opts.numThemes) : (opts.numThemes || 1);
+      const safeCount = clamp(Number.isFinite(desired) ? desired : 1, 1, 5);
+      const body = {
+        client_mutation_id: randId(),
+        actor_id: ctx.userID,
+        bypass_cache: true,
+        caller: "MESSENGER",
+        num_themes: safeCount,
+        prompt: prompt
+      };
+      if (opts.imageUrl) body.image_url = opts.imageUrl;
+      return body;
+    };
+
+    const constructForm = (input) => ({
+      av: ctx.userID,
+      __aaid: 0,
+      __user: ctx.userID,
+      __a: 1,
+      __req: utils.getSignatureID(),
+      __hs: "20358.HYP:comet_pkg.2.1...0",
+      dpr: 1,
+      __ccg: "EXCELLENT",
+      __rev: "1027673511",
+      __s: utils.getSignatureID(),
+      __hsi: "7554561631547849479",
+      __comet_req: 15,
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.jazoest,
+      lsd: ctx.fb_dtsg,
+      __spin_r: "1027673511",
+      __spin_b: "trunk",
+      __spin_t: Date.now(),
+      __crn: "comet.fbweb.MWInboxHomeRoute",
+      qpl_active_flow_ids: "25309433,521485406",
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+      variables: JSON.stringify({ input }),
+      server_timestamps: true,
+      doc_id: "23873748445608673",
+      fb_api_analytics_tags: JSON.stringify(["qpl_active_flow_ids=25309433,521485406"])
+    });
+
+    const themeNormal = (t, idx) => ({
+      success: true,
+      themeId: t.id,
+      name: t.accessibility_label,
+      description: t.description,
+      serialNumber: idx + 1,
+      colors: {
+        composerBackground: t.composer_background_color,
+        backgroundGradient: t.background_gradient_colors,
+        titleBarButton: t.title_bar_button_tint_color,
+        inboundMessageGradient: t.inbound_message_gradient_colors,
+        titleBarText: t.title_bar_text_color,
+        composerTint: t.composer_tint_color,
+        messageText: t.message_text_color,
+        primaryButton: t.primary_button_background_color,
+        titleBarBackground: t.title_bar_background_color,
+        fallback: t.fallback_color,
+        gradient: t.gradient_colors
+      },
+      backgroundImage: t.background_asset ? t.background_asset.image.uri : null,
+      iconImage: t.icon_asset ? t.icon_asset.image.uri : null,
+      images: {
+        background: t.background_asset ? t.background_asset.image.uri : null,
+        icon: t.icon_asset ? t.icon_asset.image.uri : null
+      },
+      preview_image_urls: t.preview_image_urls || null,
+      alternativeThemes: Array.isArray(t.alternative_themes)
+        ? t.alternative_themes.map(a => ({
+            id: a.id,
+            name: a.accessibility_label,
+            backgroundImage: a.background_asset ? a.background_asset.image.uri : null,
+            iconImage: a.icon_asset ? a.icon_asset.image.uri : null
+          }))
+        : []
+    });
+
+    const errorMatchers = [
+      {
+        test: (e) => !!(e && e.message && e.message.includes("not authorized")),
+        msg: "This account doesn't have permission to create AI themes. The feature may be restricted for your profile."
+      },
+      {
+        test: (e) => !!(e && e.message && e.message.includes("rate limit")),
+        msg: "You're sending requests too quickly. Please slow down and try again shortly."
+      },
+      {
+        test: (e) => !!(e && e.message && e.message.includes("Invalid")),
+        msg: "Your request contained invalid parameters. Please review your input and retry."
+      },
+      {
+        test: (e) => !!(e && e.statusCode === 403),
+        msg: "Access forbidden. Your account might not support generating Meta AI chat themes."
+      },
+      {
+        test: (e) => !!(e && e.statusCode === 429),
+        msg: "Request limit hit. Take a brief pause before sending another request."
+      }
+    ];
+
+    const friendlyError = (err) => {
+      for (let i = 0; i < errorMatchers.length; i++) {
+        if (errorMatchers[i].test(err)) return errorMatchers[i].msg;
+      }
+      return "Something went wrong while producing your theme.";
+    };
+
+    (async function run() {
+      try {
+        const formData = constructForm(makeInput());
+        const raw = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, formData);
+        const checked = await utils.parseAndCheckLogin(ctx, defaultFuncs)(raw);
+
+        if (checked.errors) throw checked.errors;
+
+        const payload = checked && checked.data && checked.data.xfb_generate_ai_themes_from_prompt;
+        if (!payload) throw new Error("Invalid response from AI theme generation");
+
+        if (!payload.success || !Array.isArray(payload.themes) || payload.themes.length === 0) {
+          throw new Error("No themes generated for the given prompt");
+        }
+
+        const normalized = payload.themes.map(themeNormal);
+        const out = {
+          success: true,
+          count: normalized.length,
+          themes: normalized,
+          ...normalized[0]
+        };
+
+        callback(null, out);
+      } catch (err) {
+        log.error("produceMetaTheme", err);
+        callback({
+          error: friendlyError(err),
+          originalError: (err && (err.message || err)) || err,
+          statusCode: err && err.statusCode ? err.statusCode : null
+        });
+      }
+    })();
+
+    return promise;
+  };
+};

package/src/apis/realtime.js

@@ -0,0 +1,161 @@
+"use strict";
+
+const { WebSocket } = require("undici");
+const EventEmitter = require("events");
+const utils = require('../utils'); 
+const HttpsProxyAgent = require("https-proxy-agent");
+
+function formatNotification(data) {
+    if (!data.data || !data.data.viewer) return null;
+    const notifEdge = data.data.viewer.notifications_page?.edges?.[1]?.node?.notif;
+    if (!notifEdge) return null;
+
+    return {
+        type: "notification",
+        notifID: notifEdge.notif_id,
+        body: notifEdge.body?.text,
+        senderID: Object.keys(notifEdge.tracking.from_uids || {})[0],
+        url: notifEdge.url,
+        timestamp: notifEdge.creation_time.timestamp,
+        seenState: notifEdge.seen_state,
+    };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function listenRealtime() {
+        const emitter = new EventEmitter();
+        let ws;
+        let reconnectTimeout;
+        let keepAliveInterval;
+
+        const subscriptions = [
+            '{"x-dgw-app-XRSS-method":"Falco","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:USER_ACTIVITY_UPDATE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9525970914181809","x-dgw-app-XRSS-routing_hint":"UserActivitySubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:ACTOR_GATEWAY_EXPERIENCE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24191710730466150","x-dgw-app-XRSS-routing_hint":"CometActorGatewayExperienceSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            `{"x-dgw-app-XRSS-method":"FBLQ:comet_notifications_live_query_experimental","x-dgw-app-XRSS-doc_id":"9784489068321501","x-dgw-app-XRSS-actor_id":"${ctx.userID}","x-dgw-app-XRSS-page_id":"${ctx.userID}","x-dgw-app-XRSS-request_stream_retry":"false","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}`,
+            '{"x-dgw-app-XRSS-method":"FBGQLS:FRIEND_REQUEST_CONFIRM_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9687616244672204","x-dgw-app-XRSS-routing_hint":"FriendingCometFriendRequestConfirmSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:FRIEND_REQUEST_RECEIVE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24047008371656912","x-dgw-app-XRSS-routing_hint":"FriendingCometFriendRequestReceiveSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:RTWEB_CALL_BLOCKED_SETTING_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24429620016626810","x-dgw-app-XRSS-routing_hint":"RTWebCallBlockedSettingSubscription_CallBlockSettingSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"PresenceUnifiedJSON","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:MESSENGER_CHAT_TABS_NOTIFICATION_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"23885219097739619","x-dgw-app-XRSS-routing_hint":"MWChatTabsNotificationSubscription_MessengerChatTabsNotificationSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:BATCH_NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"30300156509571373","x-dgw-app-XRSS-routing_hint":"CometBatchNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"23864641996495578","x-dgw-app-XRSS-routing_hint":"CometNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+            '{"x-dgw-app-XRSS-method":"FBGQLS:NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9754477301332178","x-dgw-app-XRSS-routing_hint":"CometFriendNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}'
+        ];
+
+        async function handleMessage(data) {
+            try {
+                const text = await data.text();
+                const jsonStart = text.indexOf("{");
+                if (jsonStart !== -1) {
+                    const jsonData = JSON.parse(text.substring(jsonStart));
+                    if (jsonData.code === 200) {
+                        utils.log("✅ Subscription success received.");
+                        emitter.emit("success", jsonData);
+                        return;
+                    }
+
+                    const formattedNotif = formatNotification(jsonData);
+                    if (formattedNotif) {
+                        emitter.emit("notification", formattedNotif);
+                    } else {
+                        emitter.emit("payload", jsonData);
+                    }
+                }
+            } catch (err) {
+                utils.error("❌ Error parsing WebSocket message:", err);
+                emitter.emit("error", err);
+            }
+        }
+
+        async function connect() {
+            try {
+                const queryParams = new URLSearchParams({
+                    "x-dgw-appid": "2220391788200892",
+                    "x-dgw-appversion": "0",
+                    "x-dgw-authtype": "1:0",
+                    "x-dgw-version": "5",
+                    "x-dgw-uuid": ctx.userID,
+                    "x-dgw-tier": "prod",
+                    "x-dgw-deviceid": ctx.clientID,
+                    "x-dgw-app-stream-group": "group1"
+                });
+
+                const url = `wss://gateway.facebook.com/ws/realtime?${queryParams.toString()}`;
+                const cookies = ctx.jar.getCookiesSync("https://www.facebook.com").join("; ");
+
+                const baseHeaders = {
+                    "Cookie": cookies,
+                    "Origin": "https://www.facebook.com",
+                    "User-Agent": ctx.globalOptions.userAgent,
+                    "Referer": "https://www.facebook.com",
+                    "Host": new URL(url).hostname,
+                    "Accept-Encoding": "gzip, deflate, br",
+                    "Accept-Language": "en-US,en;q=0.9"
+                };
+
+                utils.log(`📤 Headers for WebSocket handshake:\n${Object.entries(baseHeaders).map(([k, v]) => `${k}: ${v}`).join("\n")}`);
+
+                const wsOptions = { headers: baseHeaders };
+                if (ctx.globalOptions.proxy) {
+                    wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+                }
+
+                ws = new WebSocket(url, wsOptions);
+
+                ws.onopen = () => {
+                    utils.log("✅ Connected via undici.WebSocket");
+                    subscriptions.forEach((payload, index) => {
+                        const prefix = Buffer.from([14, index, 0, payload.length]);
+                        const suffix = Buffer.from([0, 0]);
+                        const fullMessage = Buffer.concat([prefix, Buffer.from(payload), suffix]);
+                        ws.send(fullMessage);
+                    });
+
+                    keepAliveInterval = setInterval(() => {
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send("ping");
+                            utils.log("🔁 Sent keep-alive ping.");
+                        }
+                    }, 10000);
+                };
+
+                ws.onmessage = (event) => {
+                    if (event.data instanceof Blob) {
+                        handleMessage(event.data);
+                    } else {
+                        utils.warn("Unknown message type:", typeof event.data);
+                    }
+                };
+
+                ws.onerror = (err) => {
+                    utils.error("WebSocket error:", err.message || err);
+                    emitter.emit("error", err);
+                };
+
+                ws.onclose = () => {
+                    utils.warn("🔌 WebSocket closed. Reconnecting...");
+                    clearInterval(keepAliveInterval);
+                    reconnectTimeout = setTimeout(connect, 1000);
+                };
+
+            } catch (err) {
+                utils.error("💥 Connection error:", err.message);
+                emitter.emit("error", err);
+                clearInterval(keepAliveInterval);
+                clearTimeout(reconnectTimeout);
+                reconnectTimeout = setTimeout(connect, 1000);
+            }
+        }
+
+        connect();
+
+        emitter.stop = () => {
+            clearInterval(keepAliveInterval);
+            clearTimeout(reconnectTimeout);
+            if (ws) ws.close();
+        };
+
+        return emitter;
+    };
+};

package/src/apis/removeUserFromGroup.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function removeUserFromGroup(userID, threadID, 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(threadID) !== "Number" && utils.getType(threadID) !== "String") {
+        throw new Error("threadID should be of type Number or String");
+      }
+      if (utils.getType(userID) !== "Number" && utils.getType(userID) !== "String") {
+        throw new Error("userID should be of type Number or String");
+      }
+
+      if (ctx.mqttClient) {
+        const reqID = ++ctx.wsReqNumber;
+        const taskID = ++ctx.wsTaskNumber;
+
+        const payload = {
+          epoch_id: utils.generateOfflineThreadingID(),
+          tasks: [
+            {
+              failure_count: null,
+              label: '140',
+              payload: JSON.stringify({
+                thread_id: threadID,
+                contact_id: userID,
+                sync_group: 1
+              }),
+              queue_name: 'remove_participant_v2',
+              task_id: taskID
+            }
+          ],
+          version_id: '8798795233522156'
+        };
+
+        const form = JSON.stringify({
+          app_id: "2220391788200892",
+          payload: JSON.stringify(payload),
+          request_id: reqID,
+          type: 3
+        });
+
+        let responseHandled = false;
+        const handleRes = (topic, message) => {
+          if (topic !== "/ls_resp" || responseHandled) return;
+          let jsonMsg;
+          try {
+            jsonMsg = JSON.parse(message.toString());
+            jsonMsg.payload = JSON.parse(jsonMsg.payload);
+          } catch {
+            return;
+          }
+          if (jsonMsg.request_id !== reqID) return;
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(null, { success: true });
+          resolveFunc({ success: true });
+        };
+
+        const timeout = setTimeout(() => {
+          if (!responseHandled) {
+            responseHandled = true;
+            ctx.mqttClient.removeListener("message", handleRes);
+            const err = new Error("MQTT request timeout");
+            callback(err);
+            rejectFunc(err);
+          }
+        }, 30000);
+
+        ctx.mqttClient.on("message", handleRes);
+        ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+          if (err && !responseHandled) {
+            responseHandled = true;
+            clearTimeout(timeout);
+            ctx.mqttClient.removeListener("message", handleRes);
+            callback(err);
+            rejectFunc(err);
+          }
+        });
+      } else {
+        const form = {
+          uid: userID,
+          tid: threadID
+        };
+
+        const res = await defaultFuncs.post("https://www.facebook.com/chat/remove_participants", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (!res || res.error) {
+          throw res || new Error("Remove from group failed");
+        }
+
+        callback(null, { success: true });
+      }
+    } catch (err) {
+      utils.error("removeUserFromGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/resolvePhotoUrl.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @module resolvePhotoUrl
+ * @description Fetches the direct URL of a Facebook photo using its photo ID.
+ * @param {Object} defaultFuncs - An object containing default request functions.
+ * @param {Object} api - Facebook API object (unused here but kept for compatibility).
+ * @param {Object} ctx - Context object containing cookies (jar) and other session info.
+ * @returns {Function} resolvePhotoUrl - A function that takes a photo ID and optional callback, and returns a Promise resolving to the photo URL.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+/**
+* @function resolvePhotoUrl
+* @param {string} photoID - The ID of the Facebook photo to resolve.
+* @param {Function} [callback] - Optional Node-style callback function `(err, photoUrl)`.
+* @returns {Promise<string>} A Promise that resolves to the direct photo URL.
+*/
+return function resolvePhotoUrl(photoID, callback) {
+let resolveFunc = function () {};
+let rejectFunc = function () {};
+const returnPromise = new Promise(function (resolve, reject) {
+resolveFunc = resolve;
+rejectFunc = reject;
+});
+
+if (!callback) {
+callback = function (err, photoUrl) {
+if (err) {
+return rejectFunc(err);
+}
+resolveFunc(photoUrl);
+};
+}
+
+defaultFuncs
+.get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+photo_id: photoID,
+})
+.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+.then((resData) => {
+if (resData.error) {
+throw resData;
+}
+
+const photoUrl = resData.jsmods.require[0][3][0];
+
+return callback(null, photoUrl);
+})
+.catch((err) => {
+utils.error("resolvePhotoUrl", err);
+return callback(err);
+});
+
+return returnPromise;
+};
+};