bb-fca 2.0.0

package/examples/post.example.js

@@ -0,0 +1,149 @@
+/**
+ * Example usage of post API functions
+ * This demonstrates how to create, delete posts, upload photos, and get comments
+ */
+
+const login = require('../module');
+
+// Your Facebook credentials
+const credentials = {
+  appState: [] // Add your appState here
+};
+
+login(credentials, (err, api) => {
+  if (err) {
+    console.error('Login failed:', err);
+    return;
+  }
+
+  console.log('Logged in successfully!');
+
+  // Example 1: Create a post
+  api.post.create({
+    message: 'Hello from bb-fca!',
+    privacy: 'SELF' // Options: 'EVERYONE', 'FRIENDS', 'SELF'
+  }, (err, result) => {
+    if (err) {
+      console.error('Error creating post:', err);
+      return;
+    }
+
+    console.log('Post created successfully!');
+    console.log('Post ID:', result.postID);
+    console.log('Success:', result.success);
+  });
+
+  // Example 2: Upload a photo
+  api.post.uploadPhoto('./path/to/your/photo.png', (err, result) => {
+    if (err) {
+      console.error('Error uploading photo:', err);
+      return;
+    }
+
+    console.log('Photo uploaded successfully!');
+    console.log('Photo ID:', result.photoID);
+    console.log('Upload ID:', result.uploadID);
+    console.log('Success:', result.success);
+  });
+
+  // Example 3: Upload photo with Promise
+  api.post.uploadPhoto('./path/to/your/photo.jpg')
+    .then(result => {
+      console.log('Photo uploaded:', result.photoID);
+    })
+    .catch(err => {
+      console.error('Upload failed:', err);
+    });
+
+  // Example 3.1: Create a post with photo attachments
+  // First upload the photo, then create post with photo ID
+  api.post.uploadPhoto('./path/to/your/photo.png')
+    .then(uploadResult => {
+      return api.post.create({
+        message: 'Check out this photo!',
+        privacy: 'SELF',
+        photos: [uploadResult.photoID] // Attach the uploaded photo
+      });
+    })
+    .then(createResult => {
+      console.log('Post with photo created successfully!');
+      console.log('Post ID:', createResult.postID);
+    })
+    .catch(err => {
+      console.error('Error:', err);
+    });
+
+  // Example 3.2: Create a post with multiple photos
+  Promise.all([
+    api.post.uploadPhoto('./photo1.jpg'),
+    api.post.uploadPhoto('./photo2.jpg'),
+    api.post.uploadPhoto('./photo3.jpg')
+  ])
+    .then(results => {
+      const photoIDs = results.map(r => r.photoID);
+      return api.post.create({
+        message: 'Multiple photos!',
+        privacy: 'FRIENDS',
+        photos: photoIDs
+      });
+    })
+    .then(result => {
+      console.log('Post with multiple photos created!');
+      console.log('Post ID:', result.postID);
+    })
+    .catch(err => {
+      console.error('Error:', err);
+    });
+
+  // Example 4: Get comments from a post
+  // URL: https://www.facebook.com/permalink.php?story_fbid=pfbid02WHHgPgDR9VuDfXiUR5KCseuh9f2NVmfwddGEgUuYKxrkJpFtqfUKbwcCBV7qAJxel&id=61588408996667
+  api.post.getComments({
+    story_fbid: 'pfbid02WHHgPgDR9VuDfXiUR5KCseuh9f2NVmfwddGEgUuYKxrkJpFtqfUKbwcCBV7qAJxel',
+    id: '61588408996667'
+  }, (err, comments) => {
+    if (err) {
+      console.error('Error getting comments:', err);
+      return;
+    }
+
+    console.log(`Found ${comments.length} comments:`);
+    comments.forEach((comment, index) => {
+      console.log(`\n--- Comment ${index + 1} ---`);
+      console.log(`ID: ${comment.id}`);
+      console.log(`GraphQL ID: ${comment.graphql_id}`);
+      console.log(`Text: ${comment.text}`);
+      console.log(`Author: ${comment.author.name} (ID: ${comment.author.id})`);
+      console.log(`Created: ${new Date(comment.created_time * 1000).toLocaleString('vi-VN')}`);
+      console.log(`Replies: ${comment.reply_count}/${comment.total_reply_count}`);
+      console.log(`Depth: ${comment.depth}`);
+
+      if (comment.replies && comment.replies.length > 0) {
+        console.log(`  Nested replies:`);
+        comment.replies.forEach((reply, i) => {
+          console.log(`  └─ [${i + 1}] ${reply.author.name}: ${reply.text}`);
+        });
+      }
+    });
+  });
+
+  // Example 5: Get comments using just the story_fbid (will use current user's ID)
+  api.post.getComments('pfbid02WHHgPgDR9VuDfXiUR5KCseuh9f2NVmfwddGEgUuYKxrkJpFtqfUKbwcCBV7qAJxel')
+    .then(comments => {
+      console.log(`\nUsing Promise: Found ${comments.length} comments`);
+    })
+    .catch(err => {
+      console.error('Error:', err);
+    });
+
+  // Example 6: Delete a post
+  api.post.delete('post_id_here', (err, result) => {
+    if (err) {
+      console.error('Error deleting post:', err);
+      return;
+    }
+
+    console.log('Post deleted successfully!');
+    console.log('Deleted Post ID:', result.postID);
+    console.log('Success:', result.success);
+  });
+});

package/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+const { login } = require('../dist/core/client');
+
+module.exports = { login };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "bb-fca",
+  "version": "2.0.0",
+  "description": "BB-FCA is a powerful and user-friendly Facebook Chat API wrapper for Node.js, designed to simplify the process of creating chatbots and automating interactions on Facebook Messenger. With BB-FCA, developers can easily send messages, manage conversations, and interact with the Facebook Messenger platform using a simple and intuitive API.",
+  "main": "dist/core/client.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && cp src/types/index.d.ts dist/index.d.ts",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\""
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "bb",
+  "license": "MIT",
+  "keywords": [
+    "bb"
+  ],
+  "dependencies": {
+    "axios": "^1.9.0",
+    "axios-cookiejar-support": "^4.0.7",
+    "chalk": "^3.0.0",
+    "cheerio": "^0.22.0",
+    "deepdash": "^5.3.9",
+    "express": "^4.19.2",
+    "form-data": "^4.0.3",
+    "freeport": "^1.0.5",
+    "gradient-string": "^1.1.0",
+    "https-proxy-agent": "^4.0.0",
+    "jsonpath-plus": "^10.3.0",
+    "lodash": "^4.17.21",
+    "mqtt": "^3.0.0",
+    "node-cron": "^3.0.3",
+    "tough-cookie": "^5.1.2",
+    "undici": "^5.29.0",
+    "websocket-stream": "^5.5.0"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/express": "^4.17.21",
+    "@types/form-data": "^2.2.1",
+    "@types/node": "^22.13.11",
+    "@types/tough-cookie": "^4.0.5",
+    "eslint": "^7.5.0",
+    "mocha": "^7.0.1",
+    "prettier": "^1.11.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=22.x"
+  }
+}

package/src/core/client.ts

@@ -0,0 +1,66 @@
+import utils = require('../utils');
+import buildAPIModel from './models/buildAPI';
+import loginHelperModel from './models/loginHelper';
+import setOptionsModel from './models/setOptions';
+
+let globalOptions: any = {};
+let ctx: any = null;
+let defaultFuncs: any = null;
+let api: any = null;
+
+const fbLink = (ext?: string): string =>
+  'https://www.facebook.com' + (ext ? '/' + ext : '');
+const ERROR_RETRIEVING =
+  'Error retrieving userID. This can be caused by many factors, including being blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.';
+
+async function login(
+  credentials: any,
+  options: any,
+  callback?: (...args: any[]) => any,
+): Promise<void> {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  if ('logging' in options) {
+    utils.logOptions(options.logging);
+  }
+  const defaultOptions = {
+    selfListen: false,
+    listenEvents: true,
+    listenTyping: false,
+    updatePresence: false,
+    forceLogin: false,
+    autoMarkDelivery: false,
+    autoMarkRead: true,
+    autoReconnect: true,
+    online: true,
+    emitReady: false,
+    userAgent:
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+  };
+  Object.assign(globalOptions, defaultOptions, options);
+
+  await setOptionsModel(globalOptions, options);
+
+  loginHelperModel(
+    credentials,
+    globalOptions,
+    (loginError, loginApi) => {
+      if (loginError) {
+        return callback(loginError);
+      }
+      api = loginApi;
+      ctx = loginApi.ctx;
+      defaultFuncs = loginApi.defaultFuncs;
+      return callback(null, loginApi);
+    },
+    setOptionsModel,
+    buildAPIModel,
+    api,
+    fbLink,
+    ERROR_RETRIEVING,
+  );
+}
+
+export { login };

package/src/core/models/buildAPI.ts

@@ -0,0 +1,131 @@
+import utils = require('../../utils');
+
+/**
+ * Builds the core API context and default functions after successful login.
+ *
+ * @param {string} html The HTML body from the initial Facebook page.
+ * @param {object} jar The cookie jar.
+ * @param {Array<object>} netData Network data extracted from the HTML.
+ * @param {object} globalOptions The global options object.
+ * @param {function} fbLinkFunc A function to generate Facebook links.
+ * @param {string} errorRetrievingMsg The error message for retrieving user ID.
+ * @returns {Array<object>} An array containing [ctx, defaultFuncs, {}].
+ */
+async function buildAPI(
+  html: string,
+  jar: any,
+  netData: any[],
+  globalOptions: any,
+  fbLinkFunc: (...args: any[]) => string,
+  errorRetrievingMsg: string,
+): Promise<[any, any, any]> {
+  let userID: string;
+  const cookies = jar.getCookiesSync(fbLinkFunc()); // Use passed fbLinkFunc
+  const primaryProfile = cookies.find((val) =>
+    val.cookieString().startsWith('c_user='),
+  );
+  const secondaryProfile = cookies.find((val) =>
+    val.cookieString().startsWith('i_user='),
+  );
+  if (!primaryProfile && !secondaryProfile) {
+    throw new Error(errorRetrievingMsg); // Use passed error message
+  }
+  userID =
+    secondaryProfile?.cookieString().split('=')[1] ||
+    primaryProfile.cookieString().split('=')[1];
+
+  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] &&
+            req[3][0].__bbox &&
+            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 dtsgData = findConfig('DTSGInitialData');
+  const dtsg: any = dtsgData
+    ? dtsgData.token
+    : utils.getFrom(html, '"token":"', '"');
+  const dtsgResult = {
+    fb_dtsg: dtsg,
+    jazoest: `2${Array.from(dtsg as string).reduce(
+      (a, b) => a + b.charCodeAt(0),
+      '',
+    )}`,
+  };
+
+  const clientIDData = findConfig('MqttWebDeviceID');
+  const clientID = clientIDData ? clientIDData.clientID : undefined;
+
+  const mqttConfigData = findConfig('MqttWebConfig');
+  const mqttAppID = mqttConfigData ? mqttConfigData.appID : undefined;
+
+  const currentUserData = findConfig('CurrentUserInitialData');
+  const userAppID = currentUserData ? currentUserData.APP_ID : undefined;
+
+  let primaryAppID = userAppID || mqttAppID;
+
+  let mqttEndpoint = mqttConfigData ? mqttConfigData.endpoint : undefined;
+
+  let region = mqttEndpoint
+    ? new URL(mqttEndpoint).searchParams.get('region')?.toUpperCase()
+    : undefined;
+  const irisSeqIDMatch = html.match(/irisSeqID:"(.+?)"/);
+  const irisSeqID = irisSeqIDMatch ? irisSeqIDMatch[1] : null;
+  if (globalOptions.bypassRegion && mqttEndpoint) {
+    const currentEndpoint = new URL(mqttEndpoint);
+    currentEndpoint.searchParams.set(
+      'region',
+      globalOptions.bypassRegion.toLowerCase(),
+    );
+    mqttEndpoint = currentEndpoint.toString();
+    region = globalOptions.bypassRegion.toUpperCase();
+  }
+
+  const ctx = {
+    userID,
+    jar,
+    clientID,
+    appID: primaryAppID,
+    mqttAppID: mqttAppID,
+    userAppID: userAppID,
+    globalOptions,
+    loggedIn: true,
+    access_token: 'NONE',
+    clientMutationId: 0,
+    mqttClient: undefined,
+    lastSeqId: irisSeqID,
+    syncToken: undefined,
+    mqttEndpoint,
+    wsReqNumber: 0,
+    wsTaskNumber: 0,
+    reqCallbacks: {},
+    callback_Task: {},
+    region,
+    firstListen: true,
+    ...dtsgResult,
+  };
+  const defaultFuncs = utils.makeDefaults(html, userID, ctx);
+
+  return [ctx, defaultFuncs, {}];
+}
+
+export default buildAPI;

package/src/core/models/loginHelper.ts

@@ -0,0 +1,226 @@
+import utils = require('../../utils');
+import axios from 'axios';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as qs from 'querystring';
+
+/**
+ * The main login helper function, orchestrating the login process.
+ *
+ * @param {object} credentials User credentials or appState.
+ * @param {object} globalOptions Global options for the API.
+ * @param {function} callback The final callback function.
+ * @param {function} setOptionsFunc Reference to the setOptions function from models.
+ * @param {function} buildAPIFunc Reference to the buildAPI function from models.
+ * @param {object} initialApi The initial API object to extend.
+ * @param {function} fbLinkFunc A function to generate Facebook links.
+ * @param {string} errorRetrievingMsg The error message for retrieving user ID.
+ * @returns {Promise<void>}
+ */
+async function loginHelper(
+  credentials: any,
+  globalOptions: any,
+  callback,
+  setOptionsFunc: any,
+  buildAPIFunc: any,
+  initialApi: any,
+  fbLinkFunc: (...args: any[]) => string,
+  errorRetrievingMsg: string,
+): Promise<void> {
+  let ctx: any = null;
+  let defaultFuncs: any = null;
+  let api: any = initialApi;
+
+  try {
+    const jar = utils.getJar();
+    utils.log('Logging in...');
+
+    const appState = credentials.appState;
+
+    if (appState) {
+      let cookieStrings = [];
+      if (Array.isArray(appState)) {
+        cookieStrings = appState.map((c) =>
+          [c.name || c.key, c.value].join('='),
+        );
+      } else if (typeof appState === 'string') {
+        cookieStrings = appState
+          .split(';')
+          .map((s) => s.trim())
+          .filter(Boolean);
+      } else {
+        throw new Error(
+          'Invalid appState format. Please provide an array of cookie objects or a cookie string.',
+        );
+      }
+
+      cookieStrings.forEach((cookieString) => {
+        const domain = '.facebook.com';
+        const expires = new Date().getTime() + 1000 * 60 * 60 * 24 * 365;
+        const str = `${cookieString}; expires=${expires}; domain=${domain}; path=/;`;
+        jar.setCookie(str, `https://${domain}`);
+      });
+    } else if (credentials.email && credentials.password) {
+      // Rui
+      const url = 'https://api.facebook.com/method/auth.login';
+      const params = {
+        access_token: '350685531728|62f8ce9f74b12f84c123cc23437a4a32',
+        format: 'json',
+        sdk_version: 2,
+        email: credentials.email,
+        locale: 'en_US',
+        password: credentials.password,
+        generate_session_cookies: 1,
+        sig: 'c1c640010993db92e5afd11634ced864',
+      };
+      const query = qs.stringify(params);
+      const xurl = `${url}?${query}`;
+      try {
+        const resp = await axios.get(xurl);
+        if (resp.status !== 200) {
+          throw new Error('Wrong password / email');
+        }
+        let cstrs = resp.data['session_cookies'].map(
+          (c) => `${c.name}=${c.value}`,
+        );
+        cstrs.forEach((cstr) => {
+          const domain = '.facebook.com';
+          const expires = new Date().getTime() + 1000 * 60 * 60 * 24 * 365;
+          const str = `${cstr}; expires=${expires}; domain=${domain}; path=/;`;
+          jar.setCookie(str, `https://${domain}`);
+        });
+      } catch (e) {
+        throw new Error('Wrong password / email');
+      }
+    } else {
+      throw new Error(
+        'No cookie or credentials found. Please provide cookies or credentials.',
+      );
+    }
+
+    if (!api) {
+      api = {
+        setOptions: setOptionsFunc.bind(null, globalOptions),
+        getAppState() {
+          const appState = utils.getAppState(jar);
+          if (!Array.isArray(appState)) return [];
+          const uniqueAppState = appState.filter(
+            (item, index, self) =>
+              self.findIndex((t) => t.key === item.key) === index,
+          );
+          return uniqueAppState.length > 0 ? uniqueAppState : appState;
+        },
+      };
+    }
+
+    const resp = await utils
+      .get(fbLinkFunc(), jar, null, globalOptions, { noRef: true })
+      .then(utils.saveCookies(jar));
+    const extractNetData = (html) => {
+      const allScriptsData = [];
+      const scriptRegex = /<script type="application\/json"[^>]*>(.*?)<\/script>/g;
+      let match;
+      while ((match = scriptRegex.exec(html)) !== null) {
+        try {
+          allScriptsData.push(JSON.parse(match[1]));
+        } catch (e) {
+          utils.error(`Failed to parse a JSON blob from HTML`, e.message);
+        }
+      }
+      return allScriptsData;
+    };
+
+    const netData = extractNetData(resp.body);
+
+    const [newCtx, newDefaultFuncs] = await buildAPIFunc(
+      resp.body,
+      jar,
+      netData,
+      globalOptions,
+      fbLinkFunc,
+      errorRetrievingMsg,
+    );
+    ctx = newCtx;
+    defaultFuncs = newDefaultFuncs;
+    api.message = new Map();
+    api.timestamp = {};
+
+    /**
+     * Loads API modules from the deltas/apis directory.
+     *
+     * @returns {void}
+     */
+    const loadApiModules = (): void => {
+      const apiPath = path.join(__dirname, '..', '..', 'deltas', 'apis');
+      const ext = __filename.endsWith('.ts') ? '.ts' : '.js';
+      const apiFolders = fs
+        .readdirSync(apiPath)
+        .filter((name: string) =>
+          fs.lstatSync(path.join(apiPath, name)).isDirectory(),
+        );
+
+      apiFolders.forEach((folder: string) => {
+        const modulePath = path.join(apiPath, folder);
+        fs.readdirSync(modulePath)
+          .filter(
+            (file: string) => file.endsWith(ext) && !file.endsWith('.d.ts'),
+          )
+          .forEach((file: string) => {
+            const moduleName = path.basename(file, ext);
+            const fullPath = path.join(modulePath, file);
+            try {
+              api[moduleName] = require(fullPath).default
+                ? require(fullPath).default(defaultFuncs, api, ctx)
+                : require(fullPath)(defaultFuncs, api, ctx);
+            } catch (e) {
+              utils.error(
+                `Failed to load module ${moduleName} from ${folder}:`,
+                e,
+              );
+            }
+          });
+      });
+      const listenPath = path.join(
+        __dirname,
+        '..',
+        '..',
+        'deltas',
+        'apis',
+        'mqtt',
+        'listenMqtt' + ext,
+      );
+      const realtimePath = path.join(
+        __dirname,
+        '..',
+        '..',
+        'deltas',
+        'apis',
+        'mqtt',
+        'realtime' + ext,
+      );
+
+      if (fs.existsSync(realtimePath)) {
+        const mod = require(realtimePath);
+        api['realtime'] = (mod.default || mod)(defaultFuncs, api, ctx);
+      }
+      if (fs.existsSync(listenPath)) {
+        const mod = require(listenPath);
+        api['listenMqtt'] = (mod.default || mod)(defaultFuncs, api, ctx);
+      }
+    };
+
+    api.getCurrentUserID = () => ctx.userID;
+    api.getOptions = (key) => (key ? globalOptions[key] : globalOptions);
+    loadApiModules();
+    api.ctx = ctx;
+    api.defaultFuncs = defaultFuncs;
+    api.globalOptions = globalOptions;
+
+    return callback(null, api);
+  } catch (error) {
+    utils.error('loginHelper', error.error || error);
+    return callback(error);
+  }
+}
+
+export default loginHelper;

package/src/core/models/setOptions.ts

@@ -0,0 +1,48 @@
+import utils = require('../../utils');
+
+async function setOptions(
+  globalOptions: any,
+  options: any = {},
+): Promise<void> {
+  const optionHandlers = {
+    online: (value) => (globalOptions.online = Boolean(value)),
+    selfListen: (value) => (globalOptions.selfListen = Boolean(value)),
+    selfListenEvent: (value) => (globalOptions.selfListenEvent = value),
+    listenEvents: (value) => (globalOptions.listenEvents = Boolean(value)),
+    updatePresence: (value) => (globalOptions.updatePresence = Boolean(value)),
+    forceLogin: (value) => (globalOptions.forceLogin = Boolean(value)),
+    userAgent: (value) => (globalOptions.userAgent = value),
+    autoMarkDelivery: (value) =>
+      (globalOptions.autoMarkDelivery = Boolean(value)),
+    autoMarkRead: (value) => (globalOptions.autoMarkRead = Boolean(value)),
+    listenTyping: (value) => (globalOptions.listenTyping = Boolean(value)),
+    proxy(value) {
+      if (typeof value !== 'string') {
+        delete globalOptions.proxy;
+        utils.setProxy();
+      } else {
+        globalOptions.proxy = value;
+        utils.setProxy(value);
+      }
+    },
+    autoReconnect: (value) => (globalOptions.autoReconnect = Boolean(value)),
+    emitReady: (value) => (globalOptions.emitReady = Boolean(value)),
+    randomUserAgent(value) {
+      globalOptions.randomUserAgent = Boolean(value);
+      if (value) {
+        globalOptions.userAgent = utils.randomUserAgent();
+      }
+    },
+    bypassRegion(value) {
+      if (value) {
+        value = value.toUpperCase();
+      }
+      globalOptions.bypassRegion = value;
+    },
+  };
+  Object.entries(options).forEach(([key, value]) => {
+    if (optionHandlers[key]) optionHandlers[key](value);
+  });
+}
+
+export default setOptions;