fca-neokex-fix 1.0.1

package/src/apis/unfriend.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function unfriend(userID, 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 {
+      const form = {
+        uid: userID,
+        unref: "bd_friends_tab",
+        floc: "friends_tab",
+        "nctr[_mod]": "pagelet_timeline_app_collection_" + ctx.userID + ":2356318349:2"
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/profile/removefriendconfirm.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.error) {
+        throw res;
+      }
+
+      callback(null, true);
+    } catch (err) {
+      utils.error("unfriend", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/unsendMessage.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async (messageID) => {
+    const defData = await defaultFuncs.post("https://www.facebook.com/messaging/unsend_message/", ctx.jar, {
+      message_id: messageID
+    })
+    const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+    if (resData.error) {
+      throw new Error(resData);
+    }
+    return resData;
+  };
+};

package/src/database/appStateBackup.js

@@ -0,0 +1,189 @@
+const models = require("./models");
+const utils = require("../utils");
+
+let uniqueIndexEnsured = false;
+
+function getBackupModel() {
+  if (!models || !models.sequelize || !models.Sequelize) return null;
+  const sequelize = models.sequelize;
+  const { DataTypes } = models.Sequelize;
+
+  if (sequelize.models && sequelize.models.AppStateBackup) {
+    return sequelize.models.AppStateBackup;
+  }
+
+  const dialect =
+    typeof sequelize.getDialect === "function"
+      ? sequelize.getDialect()
+      : "sqlite";
+  const LongText =
+    dialect === "mysql" || dialect === "mariadb"
+      ? DataTypes.TEXT("long")
+      : DataTypes.TEXT;
+
+  const AppStateBackup = sequelize.define(
+    "AppStateBackup",
+    {
+      id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+      userID: { type: DataTypes.STRING, allowNull: false },
+      type: { type: DataTypes.STRING, allowNull: false },
+      data: { type: LongText }
+    },
+    {
+      tableName: "app_state_backups",
+      timestamps: true,
+      indexes: [{ unique: true, fields: ["userID", "type"] }]
+    }
+  );
+  return AppStateBackup;
+}
+
+async function ensureUniqueIndex(sequelize) {
+  if (uniqueIndexEnsured) return;
+  try {
+    await sequelize
+      .getQueryInterface()
+      .addIndex("app_state_backups", ["userID", "type"], {
+        unique: true,
+        name: "app_state_user_type_unique"
+      });
+  } catch {}
+  uniqueIndexEnsured = true;
+}
+
+async function upsertBackup(Model, userID, type, data) {
+  const where = { userID: String(userID || ""), type };
+  const row = await Model.findOne({ where });
+  if (row) {
+    await row.update({ data });
+    utils.log(`Overwrote existing ${type} backup for user ${where.userID}`);
+    return;
+  }
+  await Model.create({ ...where, data });
+  utils.log(`Created new ${type} backup for user ${where.userID}`);
+}
+
+async function backupAppStateSQL(jar, userID) {
+  try {
+    const Model = getBackupModel();
+    if (!Model) return;
+    await Model.sync();
+    await ensureUniqueIndex(models.sequelize);
+
+    const appState = utils.getAppState(jar);
+    const cookieStr = cookieHeaderFromJar(jar);
+
+    await upsertBackup(Model, userID, "appstate", JSON.stringify(appState));
+    await upsertBackup(Model, userID, "cookie", cookieStr);
+
+    utils.log("AppState backup stored successfully");
+  } catch (e) {
+    utils.warn(
+      `Failed to save AppState backup: ${
+        e && e.message ? e.message : String(e)
+      }`
+    );
+  }
+}
+
+async function getLatestBackup(userID, type) {
+  try {
+    const Model = getBackupModel();
+    if (!Model) return null;
+    const row = await Model.findOne({
+      where: { userID: String(userID || ""), type }
+    });
+    return row ? row.data : null;
+  } catch {
+    return null;
+  }
+}
+
+async function getLatestBackupAny(type) {
+  try {
+    const Model = getBackupModel();
+    if (!Model) return null;
+    const row = await Model.findOne({
+      where: { type },
+      order: [["updatedAt", "DESC"]]
+    });
+    return row ? row.data : null;
+  } catch {
+    return null;
+  }
+}
+
+function cookieHeaderFromJar(jar) {
+  const urls = ["https://www.facebook.com", "https://www.messenger.com"];
+  const seen = new Set();
+  const parts = [];
+  for (const url of urls) {
+    let cookieString = "";
+    try {
+      if (typeof jar.getCookieStringSync === "function") {
+        cookieString = jar.getCookieStringSync(url);
+      }
+    } catch {}
+    if (!cookieString) continue;
+    for (const kv of cookieString.split(";")) {
+      const trimmed = kv.trim();
+      const name = trimmed.split("=")[0];
+      if (!name || seen.has(name)) continue;
+      seen.add(name);
+      parts.push(trimmed);
+    }
+  }
+  return parts.join("; ");
+}
+
+async function hydrateJarFromDB(jar, userID) {
+  try {
+    const { normalizeCookieHeaderString, setJarFromPairs } = require("../utils/formatters/value/formatCookie");
+    
+    let cookieHeader = null;
+    let appStateJson = null;
+
+    if (userID) {
+      cookieHeader = await getLatestBackup(userID, "cookie");
+      appStateJson = await getLatestBackup(userID, "appstate");
+    } else {
+      cookieHeader = await getLatestBackupAny("cookie");
+      appStateJson = await getLatestBackupAny("appstate");
+    }
+
+    if (cookieHeader) {
+      const pairs = normalizeCookieHeaderString(cookieHeader);
+      if (pairs.length) {
+        setJarFromPairs(jar, pairs);
+        return true;
+      }
+    }
+
+    if (appStateJson) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(appStateJson);
+      } catch {}
+      if (Array.isArray(parsed)) {
+        const pairs = parsed.map(c => [c.name || c.key, c.value].join("="));
+        setJarFromPairs(jar, pairs);
+        return true;
+      }
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  getBackupModel,
+  ensureUniqueIndex,
+  upsertBackup,
+  backupAppStateSQL,
+  getLatestBackup,
+  getLatestBackupAny,
+  hydrateJarFromDB,
+  cookieHeaderFromJar
+};

package/src/database/models/index.js

@@ -0,0 +1,56 @@
+const { Sequelize } = require("sequelize");
+const fs = require("fs");
+const path = require("path");
+
+const databasePath = path.join(process.cwd(), "neokex_fca_database");
+if (!fs.existsSync(databasePath)) {
+  fs.mkdirSync(databasePath, { recursive: true });
+}
+
+const sequelize = new Sequelize({
+  dialect: "sqlite",
+  storage: path.join(databasePath, "neokex_fca.sqlite"),
+  logging: false,
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  },
+  retry: {
+    max: 3
+  },
+  dialectOptions: {
+    timeout: 5000
+  },
+  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
+});
+
+const models = {};
+
+fs.readdirSync(__dirname)
+  .filter(file => file.endsWith(".js") && file !== "index.js")
+  .forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize);
+    models[model.name] = model;
+  });
+
+Object.keys(models).forEach(modelName => {
+  if (models[modelName].associate) {
+    models[modelName].associate(models);
+  }
+});
+
+models.sequelize = sequelize;
+models.Sequelize = Sequelize;
+
+models.syncAll = async () => {
+  try {
+    await sequelize.sync({ force: false });
+  } catch (error) {
+    console.error("Failed to synchronize fca-neokex database models:", error);
+    throw error;
+  }
+};
+
+module.exports = models;

package/src/database/models/thread.js

@@ -0,0 +1,31 @@
+module.exports = function(sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class Thread extends Model {}
+
+  Thread.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      threadID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.JSON,
+        allowNull: true
+      }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true
+    }
+  );
+  return Thread;
+};

package/src/database/models/user.js

@@ -0,0 +1,32 @@
+module.exports = function (sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class User extends Model { }
+
+  User.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      userID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.JSON,
+        allowNull: true
+      }
+    },
+    {
+      sequelize,
+      modelName: "User",
+      timestamps: true
+    }
+  );
+
+  return User;
+};

package/src/database/threadData.js

@@ -0,0 +1,101 @@
+const { Thread } = require("./models");
+
+const validateThreadID = threadID => {
+  if (typeof threadID !== "string" && typeof threadID !== "number") {
+    throw new Error("Invalid threadID: must be a string or number.");
+  }
+  return String(threadID);
+};
+
+const validateData = data => {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object.");
+  }
+};
+
+module.exports = function(api) {
+  return {
+    async create(threadID, data) {
+      try {
+        let thread = await Thread.findOne({ where: { threadID } });
+        if (thread) {
+          return { thread: thread.get(), created: false };
+        }
+        thread = await Thread.create({ threadID, ...data });
+        return { thread: thread.get(), created: true };
+      } catch (error) {
+        throw new Error(`Failed to create thread: ${error.message}`);
+      }
+    },
+
+    async get(threadID) {
+      try {
+        threadID = validateThreadID(threadID);
+        const thread = await Thread.findOne({ where: { threadID } });
+        return thread ? thread.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get thread: ${error.message}`);
+      }
+    },
+
+    async update(threadID, data) {
+      try {
+        threadID = validateThreadID(threadID);
+        validateData(data);
+        const thread = await Thread.findOne({ where: { threadID } });
+
+        if (thread) {
+          await thread.update(data);
+          return { thread: thread.get(), created: false };
+        } else {
+          const newThread = await Thread.create({ ...data, threadID });
+          return { thread: newThread.get(), created: true };
+        }
+      } catch (error) {
+        throw new Error(`Failed to update thread: ${error.message}`);
+      }
+    },
+
+    async del(threadID) {
+      try {
+        if (!threadID) {
+          throw new Error("threadID is required and cannot be undefined");
+        }
+        threadID = validateThreadID(threadID);
+        if (!threadID) {
+          throw new Error("Invalid threadID");
+        }
+        const result = await Thread.destroy({ where: { threadID } });
+        if (result === 0) {
+          throw new Error("No thread found with the specified threadID");
+        }
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to delete thread: ${error.message}`);
+      }
+    },
+
+    async delAll() {
+      try {
+        return await Thread.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all threads: ${error.message}`);
+      }
+    },
+
+    async getAll(keys = null) {
+      try {
+        const attributes =
+          typeof keys === "string"
+            ? [keys]
+            : Array.isArray(keys)
+            ? keys
+            : undefined;
+        const threads = await Thread.findAll({ attributes });
+        return threads.map(thread => thread.get());
+      } catch (error) {
+        throw new Error(`Failed to get all threads: ${error.message}`);
+      }
+    }
+  };
+};

package/src/database/userData.js

@@ -0,0 +1,90 @@
+const { User } = require("./models");
+
+const validateUserID = userID => {
+  if (typeof userID !== "string" && typeof userID !== "number") {
+    throw new Error("Invalid userID: must be a string or number.");
+  }
+  return String(userID);
+};
+
+const validateData = data => {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object.");
+  }
+};
+
+module.exports = function (api) {
+  return {
+    async create(userID, data) {
+      try {
+        userID = validateUserID(userID);
+        validateData(data);
+        let user = await User.findOne({ where: { userID } });
+        if (user) return { user: user.get(), created: false };
+        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
+        user = await User.create({ userID, ...payload });
+        return { user: user.get(), created: true };
+      } catch (error) {
+        throw new Error(`Failed to create user: ${error.message}`);
+      }
+    },
+
+    async get(userID) {
+      try {
+        userID = validateUserID(userID);
+        const user = await User.findOne({ where: { userID } });
+        return user ? user.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get user: ${error.message}`);
+      }
+    },
+
+    async update(userID, data) {
+      try {
+        userID = validateUserID(userID);
+        validateData(data);
+        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
+        const user = await User.findOne({ where: { userID } });
+        if (user) {
+          await user.update(payload);
+          return { user: user.get(), created: false };
+        } else {
+          const newUser = await User.create({ userID, ...payload });
+          return { user: newUser.get(), created: true };
+        }
+      } catch (error) {
+        throw new Error(`Failed to update user: ${error.message}`);
+      }
+    },
+
+    async del(userID) {
+      try {
+        if (!userID) throw new Error("userID is required and cannot be undefined");
+        userID = validateUserID(userID);
+        const result = await User.destroy({ where: { userID } });
+        if (result === 0) throw new Error("No user found with the specified userID");
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to delete user: ${error.message}`);
+      }
+    },
+
+    async delAll() {
+      try {
+        return await User.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all users: ${error.message}`);
+      }
+    },
+
+    async getAll(keys = null) {
+      try {
+        const attributes = typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
+        const users = await User.findAll({ attributes });
+        return users.map(u => u.get());
+      } catch (error) {
+        throw new Error(`Failed to get all users: ${error.message}`);
+      }
+    }
+  };
+};

package/src/engine/client.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const utils = require("../utils");
+const setOptionsModel = require('./models/setOptions');
+const buildAPIModel = require('./models/buildAPI');
+const loginHelperModel = require('./models/loginHelper');
+
+let globalOptions = {};
+let ctx = null;
+let defaultFuncs = null;
+let api = null;
+
+const fbLink = (ext) => ("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.";
+
+/**
+ * Initiates the login process for a Facebook account.
+ *
+ * @param {object} credentials The user's login credentials (e.g., email/password or appState cookies).
+ * @param {object} [options={}] Optional login configurations.
+ * @param {function} [callback] Optional callback function. If omitted, returns a Promise.
+ * @returns {Promise|void} Returns Promise if no callback provided, otherwise void.
+ */
+async function login(credentials, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    }
+    
+    let promiseCallback = null;
+    let rejectFunc = null;
+    let resolveFunc = null;
+    let returnPromise = null;
+
+    if (typeof callback !== "function") {
+        returnPromise = new Promise(function (resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        promiseCallback = function (error, api) {
+            if (error) return rejectFunc(error);
+            return resolveFunc(api);
+        };
+        callback = promiseCallback;
+    }
+
+    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
+    );
+
+    return returnPromise;
+}
+
+module.exports = {
+    login
+};