bb-fca 2.0.0

package/src/deltas/apis/create.ts

@@ -0,0 +1,28 @@
+/**
+ * @namespace api.create
+ * @description A collection of functions for creating and managing content on Facebook.
+ * @license Ex-it
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  const postModule = require('./posting/post').default(defaultFuncs, api, ctx);
+
+  return {
+    /**
+     * Creates a new post on Facebook.
+     * @param {string|object} options - The post content (string) or options object.
+     * @param {string} options.message - The text content of the post.
+     * @param {string} [options.privacy="SELF"] - Privacy setting: "EVERYONE", "FRIENDS", or "SELF".
+     * @param {Function} [callback] - Optional callback function.
+     * @returns {Promise<object>} The server's response containing post details.
+     */
+    addPost: postModule.create,
+
+    /**
+     * Deletes a post from Facebook.
+     * @param {string} postID - The ID of the post to delete.
+     * @param {Function} [callback] - Optional callback function.
+     * @returns {Promise<object>} The server's response.
+     */
+    deletePost: postModule.delete,
+  };
+}

package/src/deltas/apis/extra/addExternalModule.ts

@@ -0,0 +1,23 @@
+import utils = require("../../../utils");
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function addExternalModule(moduleObj) {
+    if (utils.getType(moduleObj) == "Object") {
+      for (const apiName in moduleObj) {
+        if (utils.getType(moduleObj[apiName]) == "Function") {
+          api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
+        } else {
+          throw new Error(
+            `Item "${apiName}" in moduleObj must be a function, not ${utils.getType(
+              moduleObj[apiName],
+            )}!`,
+          );
+        }
+      }
+    } else {
+      throw new Error(
+        `moduleObj must be an object, not ${utils.getType(moduleObj)}!`,
+      );
+    }
+  };
+};

package/src/deltas/apis/extra/getAccess.ts

@@ -0,0 +1,141 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function getAccess(authCode = '', callback) {
+    var cb;
+    var url = 'https://business.facebook.com/';
+    var Referer =
+      url +
+      'security/twofactor/reauth/?twofac_next=' +
+      encodeURIComponent(url + 'content_management') +
+      '&type=avoid_bypass&app_id=0&save_device=0';
+    var rt = new Promise<any>(function(resolve, reject) {
+      cb = (error, token) => (token ? resolve(token) : reject(error));
+    });
+
+    if (typeof authCode == 'function') {
+      callback = authCode;
+      authCode = '';
+    }
+    if (typeof callback == 'function') cb = callback;
+    if (!!ctx.access_token) cb(null, ctx.access_token);
+    else
+      utils
+        .get(
+          url + 'content_management',
+          ctx.jar,
+          null,
+          ctx.globalOptions,
+          null,
+          {
+            noRef: true,
+            Origin: url,
+          },
+        )
+        .then(function(res) {
+          var html = res.body;
+          var lsd = utils.getFrom(html, '["LSD",[],{"token":"', '"}');
+          return lsd;
+        })
+        .then(function(lsd) {
+          function submitCode(code) {
+            var pCb;
+            var rtPromise = new Promise<any>(function(resolve) {
+              pCb = (error, token) => resolve(cb(error, token));
+            });
+            if (typeof code != 'string')
+              pCb({
+                error: 'submitCode',
+                lerror: 'code must be string',
+                continue: submitCode,
+              });
+            else
+              defaultFuncs
+                .post(
+                  url + 'security/twofactor/reauth/enter/',
+                  ctx.jar,
+                  {
+                    approvals_code: code,
+                    save_device: true,
+                    lsd,
+                  },
+                  ctx.globalOptions,
+                  null,
+                  {
+                    Referer,
+                    Origin: url,
+                  },
+                )
+                .then(function(res) {
+                  var { payload } = JSON.parse(
+                    res.body.split(';').pop() || '{}',
+                  );
+                  if (payload && !payload.codeConfirmed)
+                    throw {
+                      error: 'submitCode',
+                      lerror: payload.message,
+                      continue: submitCode,
+                    };
+
+                  return;
+                })
+                .then(function() {
+                  return utils
+                    .get(
+                      url + 'content_management',
+                      ctx.jar,
+                      null,
+                      ctx.globalOptions,
+                      null,
+                      { noRef: true },
+                    )
+                    .then(function(res) {
+                      var html = res.body;
+                      var token = /"accessToken":"(\S+)","clientID":/g.exec(
+                        html,
+                      );
+
+                      return [html, token];
+                    });
+                })
+                .then(function(res) {
+                  if (!res[1])
+                    throw {
+                      error: 'token-undefined',
+                      htmlData: res[0],
+                    };
+                  ctx.access_token = res[1][1];
+                  return pCb(null, res[1][1]);
+                })
+                .catch(function(err) {
+                  utils.error('getAccess', err.error || err);
+                  return pCb(err);
+                });
+
+            return rtPromise;
+          }
+
+          if (authCode.length == 6 && !isNaN(authCode as any))
+            submitCode(authCode.toString());
+          else if (typeof callback == 'function')
+            throw {
+              error: 'submitCode',
+              continue: submitCode,
+            };
+          else
+            throw {
+              error:
+                'authentication code must be string or number or callback must be a function to continue',
+            };
+        })
+        .catch(function(err) {
+          utils.error(
+            'getAccess',
+            typeof callback == 'function' ? err.error || err : err,
+          );
+          return cb(err);
+        });
+
+    return rt;
+  };
+}

package/src/deltas/apis/http/httpGet.ts

@@ -0,0 +1,61 @@
+import utils = require("../../../utils");
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function httpGet(url, form, customHeader, callback, notAPI) {
+    let resolveFunc: Function = function () {};
+    let rejectFunc: Function = function () {};
+
+    const returnPromise = new Promise<any>(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      utils.getType(form) == "Function" ||
+      utils.getType(form) == "AsyncFunction"
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    if (
+      utils.getType(customHeader) == "Function" ||
+      utils.getType(customHeader) == "AsyncFunction"
+    ) {
+      callback = customHeader;
+      customHeader = {};
+    }
+
+    customHeader = customHeader || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    if (notAPI) {
+      utils
+        .get(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpGet", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .get(url, ctx.jar, form, null, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpGet", err);
+          return callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};

package/src/deltas/apis/http/httpPost.ts

@@ -0,0 +1,61 @@
+import utils = require("../../../utils");
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function httpPost(url, form, customHeader, callback, notAPI) {
+    let resolveFunc: Function = function () {};
+    let rejectFunc: Function = function () {};
+
+    const returnPromise = new Promise<any>(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      utils.getType(form) == "Function" ||
+      utils.getType(form) == "AsyncFunction"
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    if (
+      utils.getType(customHeader) == "Function" ||
+      utils.getType(customHeader) == "AsyncFunction"
+    ) {
+      callback = customHeader;
+      customHeader = {};
+    }
+
+    customHeader = customHeader || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    if (notAPI) {
+      utils
+        .post(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpPost", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .post(url, ctx.jar, form, {}, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+          })
+        .catch(function (err) {
+          utils.error("httpPost", err);
+          return callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};

package/src/deltas/apis/http/httpPostFormData.ts

@@ -0,0 +1,67 @@
+import utils = require("../../../utils");
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function httpPostFormData(url, form, customHeader, callback, notAPI) {
+    let resolveFunc: Function = function () {};
+    let rejectFunc: Function = function () {};
+
+    const returnPromise = new Promise<any>(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      utils.getType(form) == "Function" ||
+      utils.getType(form) == "AsyncFunction"
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    if (
+      utils.getType(customHeader) == "Function" ||
+      utils.getType(customHeader) == "AsyncFunction"
+    ) {
+      callback = customHeader;
+      customHeader = {};
+    }
+
+    customHeader = customHeader || {};
+
+    if (utils.getType(callback) == "Boolean") {
+      notAPI = callback;
+      callback = null;
+    }
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    if (notAPI) {
+      utils
+        .postFormData(url, ctx.jar, form, ctx.globalOptions, ctx, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpPostFormData", err);
+          return callback(err);
+        });
+    } else {
+      defaultFuncs
+        .postFormData(url, ctx.jar, form, null, customHeader)
+        .then(function (resData) {
+          callback(null, resData.body.toString());
+        })
+        .catch(function (err) {
+          utils.error("httpPostFormData", err);
+          return callback(err);
+        });
+    }
+
+    return returnPromise;
+  };
+};

package/src/deltas/apis/login/GetBotInfo.ts

@@ -0,0 +1,88 @@
+// @ChoruOfficial
+"use strict";
+
+import utils = require("../../../utils");
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(netData: Array<Object>): Object | null}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * @param {Array<Object>} netData - The array of all extracted JSON objects from the HTML.
+   * @returns {Object|null} An object containing the bot's essential info, security tokens, and context accessor functions.
+   */
+  return function GetBotInfo(netData) {
+    if (!netData || !Array.isArray(netData)) {
+        utils.error("GetBotInfo", "netData is not a valid array.");
+        return null;
+    }
+
+    /**
+     * @param {string} key The configuration key to find (e.g., "MqttWebDeviceID").
+     * @returns {Object|null} The configuration object or null if not found.
+     */
+    const findConfig = (key) => {
+        for (const scriptData of netData) {
+            if (scriptData.require) {
+                for (const req of scriptData.require) {
+                    if (Array.isArray(req) && req[0] === key && req[2]) {
+                        return req[2];
+                    }
+                    if (Array.isArray(req) && req[3] && req[3][0]?.__bbox?.define) {
+                        for (const def of req[3][0].__bbox.define) {
+                            if (Array.isArray(def) && def[0].endsWith(key) && def[2]) {
+                                return def[2];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    };
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const dtsgInitialData = findConfig("DTSGInitialData");
+    const dtsgInitData = findConfig("DTSGInitData");
+    const lsdData = findConfig("LSD");
+
+    if (!currentUserData || !dtsgInitialData) {
+        utils.error("GetBotInfo", "Could not find critical data (CurrentUserInitialData or DTSGInitialData).");
+        return null;
+    }
+
+    const botInfo = {
+        name: currentUserData.NAME,
+        firstName: currentUserData.SHORT_NAME,
+        uid: currentUserData.USER_ID,
+        appID: currentUserData.APP_ID,
+        dtsgToken: dtsgInitialData.token,
+        lsdToken: lsdData ? lsdData.token : undefined,
+        dtsgInit: dtsgInitData ? {
+            token: dtsgInitData.token,
+            async_get_token: dtsgInitData.async_get_token
+        } : undefined,
+
+        /**
+         * @param {string} key The key of the value to retrieve.
+         * @returns {any} The value from the context.
+         */
+        getCtx: (key) => ctx[key],
+
+        /**
+         * @param {string} key The key of the option to retrieve.
+         * @returns {any} The value of the option.
+         */
+        getOptions: (key) => ctx.globalOptions[key],
+
+        /**
+         * @returns {string | undefined} The current region.
+         */
+        getRegion: () => ctx?.region
+    };
+    return botInfo;
+  };
+};

package/src/deltas/apis/login/getBotInitialData.ts

@@ -0,0 +1,42 @@
+import utils = require("../../../utils");
+// @NethWs3Dev
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return async (callback) => {
+  let resolveFunc: Function = () => {};
+  let rejectFunc: Function = () => {};
+  const returnPromise = new Promise<any>((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+  });
+  if (!callback) {
+      callback = (err, data) => {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+  }
+  utils.log("Fetching account info...");
+  api.httpGet(`https://www.facebook.com/profile.php?id=${ctx.userID}`, null, {
+      customUserAgent: utils.windowsUserAgent
+  }, (err, data) => {
+  
+      if (err) throw err;
+      const profileMatch = data.match(/"CurrentUserInitialData",\[\],\{(.*?)\},(.*?)\]/);
+      if (profileMatch && profileMatch[1]){
+        const accountJson = JSON.parse(`{${profileMatch[1]}}`);
+        accountJson.name = accountJson.NAME;
+        accountJson.uid = accountJson.USER_ID;
+        delete accountJson.NAME;
+        delete accountJson.USER_ID;
+        return callback(null, {
+          ...accountJson
+      });
+      } else return callback(null, { error: "Something went wrong. Maybe its possible that it has a limitation due to spam requests. You can try again later." });
+  }, true);
+  return returnPromise;
+  };
+};
+ 
+ 

package/src/deltas/apis/login/logout.ts

@@ -0,0 +1,62 @@
+// @ChoruOfficial
+import utils = require("../../../utils");
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(): Promise<void>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Logs the current user out of Facebook.
+   * @returns {Promise<void>} A promise that resolves when logout is successful or rejects on error.
+   */
+  return async function logout() {
+    const form = {
+      pmid: "0",
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/bluebar/modern_settings_menu/?help_type=364455653583099&show_contextual_help=1",
+          ctx.jar,
+          form,
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      const elem = resData.jsmods.instances[0][2][0].find(v => v.value === "logout");
+      if (!elem) {
+        throw { error: "Could not find logout form element." };
+      }
+      
+      const html = resData.jsmods.markup.find(v => v[0] === elem.markup.__m)[1].__html;
+      
+      const logoutForm = {
+        fb_dtsg: utils.getFrom(html, '"fb_dtsg" value="', '"'),
+        ref: utils.getFrom(html, '"ref" value="', '"'),
+        h: utils.getFrom(html, '"h" value="', '"'),
+      };
+
+      const logoutRes = await defaultFuncs
+        .post("https://www.facebook.com/logout.php", ctx.jar, logoutForm)
+        .then(utils.saveCookies(ctx.jar));
+
+      if (!logoutRes.headers || !logoutRes.headers.location) {
+        throw { error: "An error occurred when logging out." };
+      }
+
+      await defaultFuncs
+        .get(logoutRes.headers.location, ctx.jar)
+        .then(utils.saveCookies(ctx.jar));
+      
+      ctx.loggedIn = false;
+      utils.log("logout", "Logged out successfully.");
+
+    } catch (err) {
+      utils.error("logout", err);
+      throw err;
+    }
+  };
+};

package/src/deltas/apis/messaging/editMessage.ts

@@ -0,0 +1,69 @@
+/**
+ * @author RFS-ADRENO
+ * @rewrittenBy Isai Ivanov
+ */
+//fixed march 30
+import utils = require('../../../utils');
+
+function canBeCalled(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * A function for editing bot's messages.
+ * @param {string} text - The text with which the bot will edit its messages.
+ * @param {string} messageID - The message ID of the message the bot will edit.
+ * @param {Object} callback - Callback for the function.
+ */
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function editMessage(text, messageID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      message_id: messageID,
+      text,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '742',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'edit_message',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context: any = {
+      app_id: '2220391788200892',
+      payload: {
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '6903494529735864',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    context.payload = JSON.stringify(context.payload);
+
+    // if (canBeCalled(callback)) {
+    // 	ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    // }
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {
+      qos: 1,
+      retain: false,
+    });
+  };
+}