@lazyneoaz/nkxchat 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,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/apis/uploadAttachment.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Uploads one or more file attachments to Facebook's servers and returns
+ * an array of attachment IDs that can be used in sendMessage({ attachment: id }).
+ *
+ * @example
+ * const fs = require("fs");
+ * const ids = await api.uploadAttachment(fs.createReadStream("./photo.jpg"));
+ * await api.sendMessage({ attachment: ids }, threadID);
+ *
+ * @param {ReadableStream|ReadableStream[]} attachments  A single stream or array of streams.
+ * @param {Function}                        [callback]   callback(err, ids[])
+ * @returns {Promise<string[]>}  Array of attachment ID strings.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  function detectType(stream) {
+    const p = (stream.path || stream._path || "").toString().toLowerCase();
+    const ext = p.split(".").pop();
+    if (["mp3", "wav", "aac", "m4a", "ogg", "opus", "flac"].includes(ext)) return { voice_clip: "true" };
+    if (["mp4", "mov", "avi", "mkv", "webm", "wmv", "flv"].includes(ext))  return { video:       "true" };
+    if (["jpg", "jpeg", "png", "gif", "bmp", "webp", "svg"].includes(ext)) return { image:       "true" };
+    return { file: "true" };
+  }
+
+  async function uploadOne(stream, threadID) {
+    if (!utils.isReadableStream(stream)) {
+      throw new Error("Each attachment must be a readable stream, not " + utils.getType(stream));
+    }
+    const form = {
+      upload_1024: stream,
+      ...detectType(stream),
+    };
+    const res = await defaultFuncs
+      .postFormData(
+        "https://upload.facebook.com/ajax/mercury/upload.php",
+        ctx.jar,
+        form,
+        {},
+        { ...ctx, requestThreadID: String(threadID || "") }
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (res.error) throw new Error(JSON.stringify(res));
+
+    const meta = res.payload && res.payload.metadata && res.payload.metadata[0];
+    if (!meta) throw new Error("Upload succeeded but no metadata returned");
+
+    // Return the first ID value in the metadata object
+    const idKey = Object.keys(meta)[0];
+    return meta[idKey];
+  }
+
+  return function uploadAttachment(attachments, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!callback) {
+      callback = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    const list = Array.isArray(attachments) ? attachments : [attachments];
+    if (!list.length) {
+      return callback(new Error("Please pass an attachment or an array of attachments."));
+    }
+
+    (async () => {
+      try {
+        const ids = [];
+        for (const stream of list) {
+          const id = await uploadOne(stream);
+          ids.push(id);
+        }
+        callback(null, ids);
+      } catch (err) {
+        utils.error("uploadAttachment", err.message || err);
+        callback(err instanceof Error ? err : new Error(String(err.message || err)));
+      }
+    })();
+
+    return promise;
+  };
+};

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