bb-fca 2.0.0

package/src/deltas/apis/mqtt/listenMqtt.ts

@@ -0,0 +1,332 @@
+import utils = require('../../../utils');
+import { EventEmitter } from 'events';
+import HttpsProxyAgent from 'https-proxy-agent';
+import mqtt from 'mqtt';
+import websocket from 'websocket-stream';
+import { parseDelta } from './deltas/value';
+
+let form: any = {};
+let getSeqID;
+const topics = [
+  '/legacy_web',
+  '/webrtc',
+  '/rtc_multi',
+  '/onevc',
+  '/br_sr',
+  '/sr_res',
+  '/t_ms',
+  '/thread_typing',
+  '/orca_typing_notifications',
+  '/notify_disconnect',
+  '/orca_presence',
+  '/inbox',
+  '/mercury',
+  '/messaging_events',
+  '/orca_message_notifications',
+  '/pp',
+  '/webrtc_response',
+];
+
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    var r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+function getRandomReconnectTime() {
+  const min = 26 * 60 * 1000;
+  const max = 60 * 60 * 1000;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function calculate(previousTimestamp, currentTimestamp) {
+  return Math.floor(
+    previousTimestamp + (currentTimestamp - previousTimestamp) + 300,
+  );
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} api
+ * @param {string} threadID
+ */
+function markAsRead(ctx, api, threadID) {
+  if (ctx.globalOptions.autoMarkRead && threadID) {
+    api.markAsRead(threadID, (err) => {
+      if (err) utils.error('autoMarkRead', err);
+    });
+  }
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @param {Function} globalCallback
+ */
+async function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
+  const chatOn = ctx.globalOptions.online;
+  const region = ctx.region;
+  const foreground = false;
+  const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+  const cid = ctx.clientID;
+  const username = {
+    u: ctx.userID,
+    s: sessionID,
+    chat_on: chatOn,
+    fg: foreground,
+    d: cid,
+    ct: 'websocket',
+    aid: ctx.mqttAppID,
+    mqtt_sid: '',
+    cp: 3,
+    ecp: 10,
+    st: [],
+    pm: [],
+    dc: '',
+    no_auto_fg: true,
+    gas: null,
+    pack: [],
+    a: ctx.globalOptions.userAgent,
+  };
+  const cookies = ctx.jar.getCookiesSync('https://www.facebook.com').join('; ');
+  let host;
+  const domain = 'wss://edge-chat.messenger.com/chat';
+  if (region) {
+    host = `${domain}?region=${region.toLowerCase()}&sid=${sessionID}&cid=${cid}`;
+  } else {
+    host = `${domain}?sid=${sessionID}&cid=${cid}`;
+  }
+
+  utils.log('Connecting to MQTT with new IDs...', host);
+
+  const options: any = {
+    clientId: 'mqttwsclient',
+    protocolId: 'MQIsdp',
+    protocolVersion: 3,
+    username: JSON.stringify(username),
+    clean: true,
+    wsOptions: {
+      headers: {
+        Cookie: cookies,
+        Origin: 'https://www.messenger.com',
+        'User-Agent': username.a,
+        Referer: 'https://www.messenger.com/',
+        Host: new URL(host).hostname,
+      },
+      origin: 'https://www.messenger.com',
+      protocolVersion: 13,
+      binaryType: 'arraybuffer',
+    },
+    keepalive: 10,
+    reschedulePings: true,
+    connectTimeout: 60000,
+    reconnectPeriod: 1000,
+  };
+
+  if (ctx.globalOptions.proxy)
+    options.wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+  const mqttClient: any = new mqtt.Client(
+    (_) => websocket(host, options.wsOptions),
+    options,
+  );
+  mqttClient.publishSync = mqttClient.publish.bind(mqttClient);
+  mqttClient.publish = (topic, message, opts = {}, callback: any = () => {}) =>
+    new Promise<any>((resolve, reject) => {
+      mqttClient.publishSync(topic, message, opts, (err, data) => {
+        if (err) {
+          callback(err);
+          reject(err);
+        }
+        callback(null, data);
+        resolve(data);
+      });
+    });
+  ctx.mqttClient = mqttClient;
+  mqttClient.on('error', (err) => {
+    utils.error('listenMqtt', err);
+    mqttClient.end();
+    if (ctx.globalOptions.autoReconnect) getSeqID();
+    else globalCallback({ type: 'stop_listen', error: 'Connection refused' });
+  });
+
+  mqttClient.on('connect', async () => {
+    topics.forEach((topic) => mqttClient.subscribe(topic));
+    const queue: any = {
+      sync_api_version: 10,
+      max_deltas_able_to_process: 1000,
+      delta_batch_size: 500,
+      encoding: 'JSON',
+      entity_fbid: ctx.userID,
+    };
+    let topic;
+    if (ctx.syncToken) {
+      topic = '/messenger_sync_get_diffs';
+      queue.last_seq_id = ctx.lastSeqId;
+      queue.sync_token = ctx.syncToken;
+    } else {
+      topic = '/messenger_sync_create_queue';
+      queue.initial_titan_sequence_id = ctx.lastSeqId;
+      queue.device_params = null;
+    }
+    utils.log(`Successfully connected to MQTT.`);
+    const {
+      name: botName = 'Facebook User',
+      uid = ctx.userID,
+    } = await api.getBotInitialData();
+    utils.log(`Hello, ${botName} (${uid})`);
+    mqttClient.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
+  });
+
+  let presenceInterval;
+  if (ctx.globalOptions.updatePresence) {
+    presenceInterval = setInterval(() => {
+      if (mqttClient.connected) {
+        const presencePayload = utils.generatePresence(ctx.userID);
+        mqttClient.publish(
+          '/orca_presence',
+          JSON.stringify({ p: presencePayload }),
+          (err) => {
+            if (err) {
+              utils.error('Failed to send presence update:', err);
+            }
+          },
+        );
+      }
+    }, 50000);
+  }
+
+  mqttClient.on('message', async (topic, message, _packet) => {
+    try {
+      const jsonMessage = JSON.parse(message.toString());
+      //const packet = JSON.parse(_packet.payload.toString());
+      if (topic === '/t_ms') {
+        if (jsonMessage.lastIssuedSeqId) {
+          ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+        }
+        if (jsonMessage.deltas) {
+          for (const delta of jsonMessage.deltas) {
+            parseDelta(defaultFuncs, api, ctx, globalCallback, { delta });
+          }
+        }
+      } else if (
+        topic === '/thread_typing' ||
+        topic === '/orca_typing_notifications'
+      ) {
+        const typ = {
+          type: 'typ',
+          isTyping: !!jsonMessage.state,
+          from: jsonMessage.sender_fbid.toString(),
+          threadID: utils.formatID(
+            (jsonMessage.thread || jsonMessage.sender_fbid).toString(),
+          ),
+        };
+        globalCallback(null, typ);
+      }
+    } catch (ex) {
+      utils.error('listenMqtt: onMessage', ex);
+    }
+  });
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  let globalCallback: Function = () => {};
+  let reconnectInterval;
+  getSeqID = async () => {
+    try {
+      form = {
+        queries: JSON.stringify({
+          o0: {
+            doc_id: '3336396659757871',
+            query_params: {
+              limit: 1,
+              before: null,
+              tags: ['INBOX'],
+              includeDeliveryReceipts: false,
+              includeSeqID: true,
+            },
+          },
+        }),
+      };
+      const resData = await defaultFuncs
+        .post('https://www.facebook.com/api/graphqlbatch/', ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      if (
+        utils.getType(resData) != 'Array' ||
+        (resData.error && resData.error !== 1357001)
+      )
+        throw resData;
+      ctx.lastSeqId =
+        resData[0].o0.data.viewer.message_threads.sync_sequence_id;
+      listenMqtt(defaultFuncs, api, ctx, globalCallback);
+    } catch (err) {
+      const descriptiveError: any = new Error(
+        'Failed to get sequence ID. This is often caused by an invalid appstate. Please try generating a new appstate.json file.',
+      );
+      descriptiveError.originalError = err;
+      return globalCallback(descriptiveError);
+    }
+  };
+
+  return async (callback) => {
+    class MessageEmitter extends EventEmitter {
+      stop() {
+        globalCallback = () => {};
+        if (reconnectInterval) {
+          clearTimeout(reconnectInterval);
+          reconnectInterval = null;
+        }
+        if (ctx.mqttClient) {
+          ctx.mqttClient.end();
+          ctx.mqttClient = undefined;
+        }
+        this.emit('stop');
+      }
+    }
+
+    const msgEmitter = new MessageEmitter();
+
+    globalCallback = (error, message) => {
+      if (error) return msgEmitter.emit('error', error);
+      if (message.type === 'message' || message.type === 'message_reply') {
+        markAsRead(ctx, api, message.threadID);
+      }
+      msgEmitter.emit('message', message);
+    };
+
+    if (typeof callback === 'function') globalCallback = callback;
+
+    if (!ctx.firstListen || !ctx.lastSeqId) await getSeqID();
+    else listenMqtt(defaultFuncs, api, ctx, globalCallback);
+
+    if (ctx.firstListen) {
+      try {
+        await api.markAsReadAll();
+      } catch (err) {
+        utils.error('Failed to mark all messages as read on startup:', err);
+      }
+    }
+
+    ctx.firstListen = false;
+
+    async function scheduleReconnect() {
+      const time = getRandomReconnectTime();
+      utils.log(
+        `Scheduled reconnect in ${Math.floor(time / 60000)} minutes...`,
+      );
+      reconnectInterval = setTimeout(() => {
+        utils.log(`Reconnecting MQTT with new clientID...`);
+        if (ctx.mqttClient) ctx.mqttClient.end(true);
+        ctx.clientID = generateUUID();
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        scheduleReconnect();
+      }, time);
+    }
+
+    scheduleReconnect();
+
+    return msgEmitter;
+  };
+}

package/src/deltas/apis/mqtt/listenSpeed.ts

@@ -0,0 +1,179 @@
+import utils = require('../../../utils');
+import { EventEmitter } from 'events';
+import HttpsProxyAgent from 'https-proxy-agent';
+import mqtt from 'mqtt';
+import websocket from 'websocket-stream';
+
+function connectLightspeed(ctx, globalCallback) {
+  let client;
+  let isStopped = false;
+
+  function startConnection(retryCount = 0) {
+    if (isStopped) return;
+
+    const chatOn = ctx.globalOptions.online;
+    const foreground = false;
+    const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+    const cookies = ctx.jar
+      .getCookiesSync('https://www.facebook.com')
+      .join('; ');
+    const cid = ctx.clientID;
+
+    const username = {
+      u: ctx.userID,
+      s: sessionID,
+      chat_on: chatOn,
+      fg: foreground,
+      d: cid,
+      ct: 'websocket',
+      aid: '2220391788200892',
+      mqtt_sid: '',
+      cp: 3,
+      ecp: 10,
+      st: [],
+      pm: [],
+      dc: '',
+      no_auto_fg: true,
+      gas: null,
+      pack: [],
+      a: ctx.globalOptions.userAgent,
+    };
+
+    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-loggingid': utils.getGUID(),
+      'x-dgw-regionhint': ctx.region || 'PRN',
+      'x-dgw-deviceid': ctx.clientID,
+    });
+    const host = `wss://gateway.facebook.com/ws/lightspeed?${queryParams.toString()}`;
+
+    const options: any = {
+      clientId: 'mqttwsclient',
+      protocolId: 'MQIsdp',
+      protocolVersion: 3,
+      username: JSON.stringify(username),
+      clean: true,
+      wsOptions: {
+        headers: {
+          Cookie: cookies,
+          Origin: 'https://www.facebook.com',
+          'User-Agent': username.a,
+          Referer: 'https://www.facebook.com/',
+          Host: new URL(host).hostname,
+        },
+      },
+      keepalive: 10,
+      reconnectPeriod: 0,
+    };
+
+    if (ctx.globalOptions.proxy) {
+      options.wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+    }
+
+    try {
+      client = new mqtt.Client(
+        (_) => websocket(host, options.wsOptions),
+        options,
+      );
+      utils.log('[Lightspeed] Attempting MQTT connection...');
+    } catch (err) {
+      utils.error('[Lightspeed] MQTT Client creation failed:', err.message);
+      reconnect(retryCount + 1);
+      return;
+    }
+
+    client.on('connect', () => {
+      utils.log(
+        '[Lightspeed] MQTT client connected. Attempting to subscribe to topics...',
+      );
+      retryCount = 0;
+
+      // --- ITO ANG IDINAGDAG NA SUBSCRIBE LOGIC ---
+      const topicsToSubscribe = [
+        '/t_ms', // Para sa mga messages at deltas
+        '/orca_presence', // Para sa online status
+        '/messaging_events', // Para sa ibang events
+      ];
+
+      topicsToSubscribe.forEach((topic) => {
+        client.subscribe(topic, (err) => {
+          if (err) {
+            utils.error(
+              `[Lightspeed] Failed to subscribe to topic ${topic}:`,
+              err.message,
+            );
+          } else {
+            utils.log(`[Lightspeed] Subscribed to topic: ${topic}`);
+          }
+        });
+      });
+      // -----------------------------------------
+    });
+
+    client.on('message', (topic, payload) => {
+      utils.log(`[Lightspeed] Payload Received on topic ${topic}:`);
+      globalCallback(null, {
+        type: 'lightspeed_message',
+        topic: topic.toString(),
+        payload: payload,
+      });
+    });
+
+    client.on('close', () => {
+      utils.warn(`[Lightspeed] Connection closed.`);
+      if (!isStopped) {
+        reconnect(retryCount + 1);
+      }
+    });
+
+    client.on('error', (err) => {
+      utils.error('[Lightspeed] MQTT Connection Error:', err.message);
+    });
+  }
+
+  function reconnect(retryCount) {
+    const delay = Math.min(3000 * Math.pow(2, retryCount), 60000);
+    utils.log(`[Lightspeed] Reconnecting in ${delay / 1000} seconds...`);
+    setTimeout(() => startConnection(retryCount), delay);
+  }
+
+  startConnection();
+
+  return {
+    stop: () => {
+      isStopped = true;
+      if (client) client.end(true);
+      utils.log('[Lightspeed] Listener has been manually stopped.');
+    },
+  };
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return (callback) => {
+    class MessageEmitter extends EventEmitter {
+      listener: any = null;
+      stop() {
+        if (this.listener) {
+          this.listener.stop();
+        }
+        this.emit('stop');
+      }
+    }
+    const msgEmitter = new MessageEmitter();
+    const globalCallback = (error, message) => {
+      if (error) return msgEmitter.emit('error', error);
+      msgEmitter.emit('message', message);
+    };
+    if (typeof callback === 'function') {
+      msgEmitter.listener = connectLightspeed(ctx, callback);
+    } else {
+      msgEmitter.listener = connectLightspeed(ctx, globalCallback);
+    }
+    return msgEmitter;
+  };
+}

package/src/deltas/apis/mqtt/pinMessage.ts

@@ -0,0 +1,135 @@
+import utils = require("../../../utils"); 
+import * as fs from "fs";
+import * as path from "path";
+import _ from "lodash";
+import deepdash from "deepdash";
+import { JSONPath } from "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;
+  }
+
+  // Save the entire object for debugging
+  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);
+  }
+
+  // 🔍 Use JSONPath to search for both commands
+  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;
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  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);
+
+        // Extract, save and search commands inside lightspeed_web_request
+        const lightReq = extractAndSearchLightspeedRequest(allJsonData);
+        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<any>((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".`);
+  };
+};