@lazyneoaz/testfca 1.0.0

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,25 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async (messageID) => {
+    // E2EE routing: unsendMessage({ chatJid, messageId })
+    if (utils.getType(messageID) === "Object" && messageID.chatJid && messageID.messageId) {
+      if (!api.e2ee || !api.e2ee.isAvailable()) throw new Error("E2EE bridge not available");
+      const status = api.e2ee.isConnected();
+      if (!status.connected || !status.e2eeConnected) throw new Error("E2EE not connected. Call api.e2ee.connect() and api.e2ee.connectE2EE() first.");
+      return api.e2ee.unsendE2EEMessage(messageID.chatJid, messageID.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,298 @@
+const models = require("./models");
+const utils = require("../utils");
+
+let uniqueIndexEnsured = false;
+let autoBackupInterval = null;
+
+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 },
+      // Add expiry tracking for better session management
+      expiresAt: { type: DataTypes.DATE, allowNull: true },
+      lastActivityAt: { type: DataTypes.DATE, allowNull: true, defaultValue: DataTypes.NOW }
+    },
+    {
+      tableName: "app_state_backups",
+      timestamps: true,
+      indexes: [
+        { unique: true, fields: ["userID", "type"] },
+        { fields: ["expiresAt"] },
+        { fields: ["lastActivityAt"] }
+      ]
+    }
+  );
+  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, expiresAt = null) {
+  const where = { userID: String(userID || ""), type };
+  const updateData = { 
+    data, 
+    lastActivityAt: new Date(),
+    ...(expiresAt && { expiresAt })
+  };
+  
+  const row = await Model.findOne({ where });
+  if (row) {
+    await row.update(updateData);
+    utils.log(`Overwrote existing ${type} backup for user ${where.userID}`);
+    return;
+  }
+  await Model.create({ ...where, ...updateData });
+  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);
+    
+    // Calculate cookie expiry (default to 90 days if not determinable)
+    let expiresAt = null;
+    try {
+      const cookies = jar.getCookiesSync("https://www.facebook.com");
+      const cUserCookie = cookies.find(c => c.key === "c_user");
+      if (cUserCookie && cUserCookie.expires) {
+        expiresAt = new Date(cUserCookie.expires);
+      } else {
+        // Default 90 days from now
+        expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000);
+      }
+    } catch (e) {
+      expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000);
+    }
+
+    await upsertBackup(Model, userID, "appstate", JSON.stringify(appState), expiresAt);
+    await upsertBackup(Model, userID, "cookie", cookieStr, expiresAt);
+
+    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;
+  }
+}
+
+/**
+ * Start automatic periodic backup of appState
+ * @param {Object} jar - Cookie jar
+ * @param {string} userID - User ID
+ * @param {number} intervalMs - Backup interval in milliseconds (default: 5 minutes)
+ */
+function startAutoBackup(jar, userID, intervalMs = 5 * 60 * 1000) {
+  // Clear existing interval if any
+  if (autoBackupInterval) {
+    clearInterval(autoBackupInterval);
+    autoBackupInterval = null;
+  }
+  
+  autoBackupInterval = setInterval(async () => {
+    try {
+      await backupAppStateSQL(jar, userID);
+      utils.log("AppStateBackup", `Auto-backup completed for user ${userID}`);
+    } catch (err) {
+      utils.warn("AppStateBackup", "Auto-backup failed:", err.message);
+    }
+  }, intervalMs);
+  
+  utils.log("AppStateBackup", `Auto-backup started (interval: ${intervalMs}ms)`);
+}
+
+/**
+ * Stop automatic backup
+ */
+function stopAutoBackup() {
+  if (autoBackupInterval) {
+    clearInterval(autoBackupInterval);
+    autoBackupInterval = null;
+    utils.log("AppStateBackup", "Auto-backup stopped");
+  }
+}
+
+/**
+ * Update session activity timestamp
+ * @param {string} userID - User ID
+ */
+async function updateSessionActivity(userID) {
+  try {
+    const Model = getBackupModel();
+    if (!Model) return;
+    
+    await Model.update(
+      { lastActivityAt: new Date() },
+      { where: { userID: String(userID || "") } }
+    );
+  } catch (e) {
+    // Silent fail - not critical
+  }
+}
+
+/**
+ * Check if session is still valid based on expiry
+ * @param {string} userID - User ID
+ * @returns {Promise<boolean>}
+ */
+async function isSessionValid(userID) {
+  try {
+    const Model = getBackupModel();
+    if (!Model) return true;
+    
+    const row = await Model.findOne({
+      where: { userID: String(userID || ""), type: "appstate" }
+    });
+    
+    if (!row || !row.expiresAt) return true;
+    
+    return new Date(row.expiresAt) > new Date();
+  } catch {
+    return true;
+  }
+}
+
+module.exports = {
+  getBackupModel,
+  ensureUniqueIndex,
+  upsertBackup,
+  backupAppStateSQL,
+  getLatestBackup,
+  getLatestBackupAny,
+  hydrateJarFromDB,
+  cookieHeaderFromJar,
+  startAutoBackup,
+  stopAutoBackup,
+  updateSessionActivity,
+  isSessionValid
+};

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(), "nkxfca_database");
+if (!fs.existsSync(databasePath)) {
+  fs.mkdirSync(databasePath, { recursive: true });
+}
+
+const sequelize = new Sequelize({
+  dialect: "sqlite",
+  storage: path.join(databasePath, "nkxfca.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 nkxfca 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: "FcaNeoProThread",
+      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: "FcaNeoProUser",
+      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}`);
+      }
+    }
+  };
+};