autobot-fca 1.0.0

package/dist/index.cjs

@@ -0,0 +1,936 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_FCA_CONFIG: () => DEFAULT_FCA_CONFIG,
+  appStateToCookie: () => appStateToCookie,
+  attachClientFacade: () => attachClientFacade,
+  cookieToAppState: () => cookieToAppState,
+  createFcaClient: () => createFcaClient,
+  createMessengerBot: () => createMessengerBot,
+  dedupeCookiePairs: () => dedupeCookiePairs,
+  default: () => index_default,
+  loadConfig: () => loadConfig,
+  login: () => login,
+  normalizeCookiePayload: () => normalizeCookiePayload,
+  parseCookieHeaderString: () => parseCookieHeaderString,
+  parseNetscapeCookieText: () => parseNetscapeCookieText,
+  resolveConfig: () => resolveConfig,
+  toCookiePair: () => toCookiePair,
+  toNetscapeCookieText: () => toNetscapeCookieText
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+function createFcaClient(api) {
+  const existingClient = api.client || {};
+  const messages = {
+    send: api.messages && api.messages.send || api.sendMessage || existingClient.messages && existingClient.messages.send || ((msg, tid) => ({ messageID: "mid." + Date.now(), threadID: tid })),
+    edit: api.messages && api.messages.edit || api.editMessage || existingClient.messages && existingClient.messages.edit || ((text, mid) => ({ success: true, messageID: mid, text, timestamp: Date.now() })),
+    reply: api.messages && api.messages.reply || api.replyMessage || existingClient.messages && existingClient.messages.reply || ((msg, mid) => ({ messageID: "mid." + Date.now(), replyTo: mid })),
+    unsend: api.messages && api.messages.unsend || api.unsendMessage || existingClient.messages && existingClient.messages.unsend || ((mid) => ({ success: true, messageID: mid })),
+    forward: api.messages && api.messages.forward || api.forwardMessage || existingClient.messages && existingClient.messages.forward || ((mid, tid) => ({ success: true, messageID: mid, threadID: tid })),
+    react: api.messages && api.messages.react || api.setMessageReaction || existingClient.messages && existingClient.messages.react || ((reaction, mid) => ({ success: true, reaction, messageID: mid })),
+    delete: api.messages && api.messages.delete || api.deleteMessage || existingClient.messages && existingClient.messages.delete || ((mids) => ({ success: true, messageIDs: Array.isArray(mids) ? mids : [mids] })),
+    sendTypingIndicator: api.messages && api.messages.sendTypingIndicator || api.sendTypingIndicator || existingClient.messages && existingClient.messages.sendTypingIndicator || ((tid) => () => {
+    })
+  };
+  const threads = {
+    getInfo: api.threads && api.threads.getInfo || api.getThreadInfo || existingClient.threads && existingClient.threads.getInfo || ((tid) => ({ threadID: tid, threadName: "Thread " + tid, participantIDs: [], isGroup: false })),
+    getList: api.threads && api.threads.getList || api.getThreadList || existingClient.threads && existingClient.threads.getList || ((limit = 20) => []),
+    getHistory: api.threads && api.threads.getHistory || api.getThreadHistory || existingClient.threads && existingClient.threads.getHistory || ((tid, amount = 20) => []),
+    getPictures: api.threads && api.threads.getPictures || api.getThreadPictures || existingClient.threads && existingClient.threads.getPictures || ((tid) => []),
+    setTitle: api.threads && api.threads.setTitle || api.setTitle || existingClient.threads && existingClient.threads.setTitle || ((title, tid) => ({ success: true, title, threadID: tid })),
+    changeColor: api.threads && api.threads.changeColor || api.changeThreadColor || existingClient.threads && existingClient.threads.changeColor || ((color, tid) => ({ success: true, color, threadID: tid })),
+    changeEmoji: api.threads && api.threads.changeEmoji || api.changeThreadEmoji || existingClient.threads && existingClient.threads.changeEmoji || ((emoji, tid) => ({ success: true, emoji, threadID: tid })),
+    changeNickname: api.threads && api.threads.changeNickname || api.changeNickname || existingClient.threads && existingClient.threads.changeNickname || ((nick, tid, pid) => ({ success: true, nickname: nick, threadID: tid, participantID: pid })),
+    changeGroupImage: api.threads && api.threads.changeGroupImage || api.changeGroupImage || existingClient.threads && existingClient.threads.changeGroupImage || ((img, tid) => ({ success: true, threadID: tid })),
+    changeAdminStatus: api.threads && api.threads.changeAdminStatus || api.changeAdminStatus || existingClient.threads && existingClient.threads.changeAdminStatus || ((tid, aids, status) => ({ success: true, threadID: tid, adminIDs: aids, adminStatus: status })),
+    changeArchivedStatus: api.threads && api.threads.changeArchivedStatus || api.changeArchivedStatus || existingClient.threads && existingClient.threads.changeArchivedStatus || ((tid, archive) => ({ success: true, threadID: tid, isArchived: archive })),
+    addUser: api.threads && api.threads.addUser || api.addUserToGroup || existingClient.threads && existingClient.threads.addUser || ((uids, tid) => ({ success: true, userIDs: uids, threadID: tid })),
+    removeUser: api.threads && api.threads.removeUser || api.removeUserFromGroup || existingClient.threads && existingClient.threads.removeUser || ((uid, tid) => ({ success: true, userID: uid, threadID: tid })),
+    createPoll: api.threads && api.threads.createPoll || api.createPoll || existingClient.threads && existingClient.threads.createPoll || ((title, opts, tid) => ({ success: true, title, threadID: tid })),
+    deleteThread: api.threads && api.threads.deleteThread || api.deleteThread || existingClient.threads && existingClient.threads.deleteThread || ((tids) => ({ success: true, threadIDs: tids })),
+    markAsRead: api.threads && api.threads.markAsRead || api.markAsRead || existingClient.threads && existingClient.threads.markAsRead || ((tid) => ({ success: true, threadID: tid }))
+  };
+  const users = {
+    getInfo: api.users && api.users.getInfo || api.getUserInfo || existingClient.users && existingClient.users.getInfo || ((ids) => {
+      const arr = Array.isArray(ids) ? ids : [ids];
+      const res = {};
+      for (const id of arr) {
+        res[id] = { id, name: "User " + id, firstName: "User", isFriend: true };
+      }
+      return res;
+    }),
+    getUserID: api.users && api.users.getUserID || api.getUserID || existingClient.users && existingClient.users.getUserID || ((name) => [{ id: "100010001000101", name }]),
+    getFriendsList: api.users && api.users.getFriendsList || api.getFriendsList || existingClient.users && existingClient.users.getFriendsList || (() => []),
+    block: api.users && api.users.block || api.blockUser || existingClient.users && existingClient.users.block || ((uid) => ({ success: true, userID: uid, blocked: true })),
+    unblock: api.users && api.users.unblock || api.unblockUser || existingClient.users && existingClient.users.unblock || ((uid) => ({ success: true, userID: uid, blocked: false }))
+  };
+  const account = {
+    getCurrentUserID: api.account && api.account.getCurrentUserID || api.getCurrentUserID || existingClient.account && existingClient.account.getCurrentUserID || (() => "100000000000000"),
+    getAppState: api.account && api.account.getAppState || api.getAppState || existingClient.account && existingClient.account.getAppState || (() => []),
+    setOptions: api.account && api.account.setOptions || api.setOptions || existingClient.account && existingClient.account.setOptions || (() => {
+    }),
+    setBio: api.account && api.account.setBio || api.setBio || existingClient.account && existingClient.account.setBio || ((bio) => ({ success: true, bio }))
+  };
+  const realtime = {
+    listen: api.realtime && api.realtime.listen || api.listenMqtt || api.listen || existingClient.realtime && existingClient.realtime.listen || ((cb) => () => {
+    }),
+    stopListening: api.realtime && api.realtime.stopListening || api.stopListening || existingClient.realtime && existingClient.realtime.stopListening || (() => {
+    }),
+    stopListeningAsync: api.realtime && api.realtime.stopListeningAsync || api.stopListeningAsync || existingClient.realtime && existingClient.realtime.stopListeningAsync || (() => Promise.resolve(true))
+  };
+  const http = {
+    get: api.http && api.http.get || api.httpGet || existingClient.http && existingClient.http.get || (async (url) => ({ status: 200, data: {} })),
+    post: api.http && api.http.post || api.httpPost || existingClient.http && existingClient.http.post || (async (url, body) => ({ status: 200, data: {} })),
+    postFormData: api.http && api.http.postFormData || api.postFormData || existingClient.http && existingClient.http.postFormData || (async (url, formData) => ({ status: 200, data: {} }))
+  };
+  const scheduler = {
+    scheduleMessage: api.scheduler && api.scheduler.scheduleMessage || existingClient.scheduler && existingClient.scheduler.scheduleMessage || ((message, threadID, timestamp) => ({
+      scheduled: true,
+      message,
+      threadID,
+      timestamp: timestamp || Date.now()
+    }))
+  };
+  const client = {
+    messages,
+    threads,
+    users,
+    account,
+    realtime,
+    http,
+    scheduler
+  };
+  return client;
+}
+function attachClientFacade(api) {
+  const client = createFcaClient(api);
+  api.client = client;
+  api.messages = client.messages;
+  api.threads = client.threads;
+  api.users = client.users;
+  api.account = client.account;
+  api.realtime = client.realtime;
+  api.http = client.http;
+  api.scheduler = client.scheduler;
+  return client;
+}
+
+// src/api.ts
+var FcaApiInstance = class {
+  _currentUserID;
+  _options;
+  _middlewares = [];
+  _middlewareEnabled = true;
+  _activeListeners = /* @__PURE__ */ new Set();
+  _listenerInterval = null;
+  handleReply = /* @__PURE__ */ new Map();
+  handleReaction = /* @__PURE__ */ new Map();
+  handleSchedule = /* @__PURE__ */ new Map();
+  client;
+  messages;
+  threads;
+  users;
+  account;
+  realtime;
+  http;
+  scheduler;
+  constructor(userID = "100000000000000", options = {}) {
+    this._currentUserID = userID;
+    this._options = {
+      online: true,
+      forceLogin: false,
+      autoMarkRead: false,
+      listenEvents: true,
+      selfListen: false,
+      logLevel: "info",
+      ...options
+    };
+    attachClientFacade(this);
+  }
+  getCurrentUserID() {
+    return this._currentUserID;
+  }
+  setOptions(opts) {
+    this._options = { ...this._options, ...opts };
+  }
+  getAppState() {
+    return [
+      { key: "c_user", value: this._currentUserID, domain: ".facebook.com", path: "/" },
+      { key: "xs", value: "mock_session_token", domain: ".facebook.com", path: "/" }
+    ];
+  }
+  useMiddleware(fn) {
+    if (typeof fn === "function" && !this._middlewares.includes(fn)) {
+      this._middlewares.push(fn);
+    }
+  }
+  removeMiddleware(fn) {
+    this._middlewares = this._middlewares.filter((m) => m !== fn);
+  }
+  clearMiddleware() {
+    this._middlewares = [];
+  }
+  listMiddleware() {
+    return [...this._middlewares];
+  }
+  setMiddlewareEnabled(enabled) {
+    this._middlewareEnabled = Boolean(enabled);
+    return this._middlewareEnabled;
+  }
+  async sendMessage(message, threadID, callback) {
+    const payload = typeof message === "string" ? { body: message } : message;
+    const result = {
+      messageID: `mid.$gA${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
+      threadID: String(threadID),
+      timestamp: Date.now(),
+      body: payload.body || "",
+      status: "sent"
+    };
+    if (typeof callback === "function") {
+      callback(null, result);
+    }
+    return result;
+  }
+  async editMessage(text, messageID, callback) {
+    const result = {
+      success: true,
+      messageID: String(messageID),
+      text: String(text),
+      timestamp: Date.now()
+    };
+    if (typeof callback === "function") {
+      callback(null, result);
+    }
+    return result;
+  }
+  async replyMessage(message, messageID, callback) {
+    const payload = typeof message === "string" ? { body: message } : message;
+    const result = {
+      messageID: `mid.$gA${Date.now()}_reply`,
+      replyToMessageID: String(messageID),
+      timestamp: Date.now(),
+      body: payload.body || "",
+      status: "sent"
+    };
+    if (typeof callback === "function") {
+      callback(null, result);
+    }
+    return result;
+  }
+  async unsendMessage(messageID, callback) {
+    const result = {
+      success: true,
+      messageID: String(messageID),
+      unsendTime: Date.now()
+    };
+    if (typeof callback === "function") {
+      callback(null, result);
+    }
+    return result;
+  }
+  async setMessageReaction(reaction, messageID, callback, force = false) {
+    const result = {
+      success: true,
+      reaction: String(reaction || "\u{1F44D}"),
+      messageID: String(messageID),
+      timestamp: Date.now()
+    };
+    if (typeof callback === "function") callback(null, result);
+    return result;
+  }
+  sendTypingIndicator(threadID, callback) {
+    let isTyping = true;
+    const end = (cb) => {
+      isTyping = false;
+      if (typeof cb === "function") cb(null);
+    };
+    if (typeof callback === "function") {
+      callback(null, end);
+    }
+    return end;
+  }
+  async deleteMessage(messageIDs, callback) {
+    const arr = Array.isArray(messageIDs) ? messageIDs : [messageIDs];
+    const result = { success: true, deletedCount: arr.length, messageIDs: arr };
+    if (typeof callback === "function") callback(null, result);
+    return result;
+  }
+  async forwardAttachment(attachmentID, threadID, callback) {
+    const result = { success: true, attachmentID: String(attachmentID), threadID: String(threadID), timestamp: Date.now() };
+    if (typeof callback === "function") callback(null, result);
+    return result;
+  }
+  async getThreadInfo(threadID, callback) {
+    const info = {
+      threadID: String(threadID),
+      threadName: `Thread ${threadID}`,
+      participantIDs: [this._currentUserID, String(threadID)],
+      userInfo: [
+        { id: this._currentUserID, name: "Bot Account" },
+        { id: String(threadID), name: `User ${threadID}` }
+      ],
+      unreadCount: 0,
+      messageCount: 42,
+      isGroup: false,
+      isArchived: false,
+      emoji: "\u{1F44D}",
+      color: "#0084FF",
+      adminIDs: [this._currentUserID],
+      nicknames: {}
+    };
+    if (typeof callback === "function") {
+      callback(null, info);
+    }
+    return info;
+  }
+  async getThreadHistory(threadID, amount = 20, timestamp, callback) {
+    const history = Array.from({ length: Math.min(amount, 20) }, (_, i) => ({
+      messageID: `mid.$hist_${Date.now() - i * 6e4}`,
+      threadID: String(threadID),
+      senderID: i % 2 === 0 ? this._currentUserID : String(threadID),
+      body: `Message ${i + 1} from history`,
+      timestamp: Date.now() - i * 6e4
+    }));
+    if (typeof callback === "function") callback(null, history);
+    return history;
+  }
+  async getThreadPictures(threadID, offset = 0, limit = 10, callback) {
+    const pictures = [];
+    if (typeof callback === "function") callback(null, pictures);
+    return pictures;
+  }
+  async getUserInfo(userIDs, callback) {
+    const ids = Array.isArray(userIDs) ? userIDs : [userIDs];
+    const result = {};
+    for (const id of ids) {
+      result[id] = {
+        id: String(id),
+        name: `User ${id}`,
+        firstName: "User",
+        vanity: `user.${id}`,
+        thumbSrc: `https://graph.facebook.com/${id}/picture?type=small`,
+        profileUrl: `https://facebook.com/${id}`,
+        gender: "unknown",
+        type: "user",
+        isFriend: true,
+        isBirthday: false
+      };
+    }
+    if (typeof callback === "function") {
+      callback(null, result);
+    }
+    return result;
+  }
+  async getUserID(name, callback) {
+    const result = [{ id: "100010001000101", name: String(name) }];
+    if (typeof callback === "function") callback(null, result);
+    return result;
+  }
+  async getFriendsList(callback) {
+    const friends = [
+      { id: "100010001000101", name: "Alex Rivers", vanity: "alex.rivers", isFriend: true },
+      { id: "100020002000202", name: "Sarah Jenkins", vanity: "sarah.jenkins", isFriend: true }
+    ];
+    if (typeof callback === "function") callback(null, friends);
+    return friends;
+  }
+  async blockUser(userID, callback) {
+    const res = { success: true, userID: String(userID), blocked: true };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async unblockUser(userID, callback) {
+    const res = { success: true, userID: String(userID), blocked: false };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async setBio(bio, publishId = false, callback) {
+    const res = { success: true, bio: String(bio), publishId };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  listenMqtt(callback) {
+    if (typeof callback === "function") {
+      this._activeListeners.add(callback);
+    }
+    const stopFn = () => {
+      if (typeof callback === "function") {
+        this._activeListeners.delete(callback);
+      }
+    };
+    return stopFn;
+  }
+  stopListening(callback) {
+    this._activeListeners.clear();
+    if (this._listenerInterval) {
+      clearInterval(this._listenerInterval);
+      this._listenerInterval = null;
+    }
+    if (typeof callback === "function") {
+      callback(null);
+    }
+  }
+  async stopListeningAsync() {
+    this.stopListening();
+    return true;
+  }
+  async httpGet(url, params, callback) {
+    const res = { status: 200, data: { success: true, url, params } };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async httpPost(url, body, callback) {
+    const res = { status: 200, data: { success: true, url, body } };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async postFormData(url, formData, callback) {
+    const res = { status: 200, data: { success: true, url, formData } };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async getThreadList(limit = 20, timestamp, tags, callback) {
+    const list = [
+      {
+        threadID: "100010001000101",
+        threadName: "Messenger Community Chat",
+        participantIDs: [this._currentUserID, "100010001000101", "100010001000102"],
+        unreadCount: 0,
+        messageCount: 154,
+        isGroup: true,
+        emoji: "\u{1F525}",
+        color: "#1877F2"
+      },
+      {
+        threadID: "100020002000202",
+        threadName: "Sarah Jenkins",
+        participantIDs: [this._currentUserID, "100020002000202"],
+        unreadCount: 1,
+        messageCount: 88,
+        isGroup: false,
+        emoji: "\u2764\uFE0F",
+        color: "#FF5E3A"
+      }
+    ];
+    if (typeof callback === "function") callback(null, list);
+    return list;
+  }
+  async markAsRead(threadID, callback) {
+    const res = { success: true, threadID };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async markAsReadAll(callback) {
+    const res = { success: true, readAll: true, timestamp: Date.now() };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async markAsSeen(seen = true, callback) {
+    const res = { success: true, seen, timestamp: Date.now() };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async markAsDelivered(threadID, messageID, callback) {
+    const res = { success: true, threadID, messageID, timestamp: Date.now() };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async setTitle(newTitle, threadID, callback) {
+    const res = { success: true, threadID, title: newTitle };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeThreadColor(color, threadID, callback) {
+    const res = { success: true, threadID, color };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeThreadEmoji(emoji, threadID, callback) {
+    const res = { success: true, threadID, emoji };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeNickname(nickname, threadID, participantID, callback) {
+    const res = { success: true, threadID, participantID, nickname };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeGroupImage(image, threadID, callback) {
+    const res = { success: true, threadID, imageUpdated: true };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeAdminStatus(threadID, adminIDs, adminStatus, callback) {
+    const aids = Array.isArray(adminIDs) ? adminIDs : [adminIDs];
+    const res = { success: true, threadID, adminIDs: aids, adminStatus };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async changeArchivedStatus(threadID, archive, callback) {
+    const res = { success: true, threadID, isArchived: archive };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async addUserToGroup(userID, threadID, callback) {
+    const uids = Array.isArray(userID) ? userID : [userID];
+    const res = { success: true, threadID, addedUserIDs: uids };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async removeUserFromGroup(userID, threadID, callback) {
+    const res = { success: true, threadID, removedUserID: String(userID) };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async createPoll(title, options, threadID, callback) {
+    const opts = Array.isArray(options) ? Object.fromEntries(options.map((o) => [o, false])) : options;
+    const res = { success: true, pollID: `poll_${Date.now()}`, threadID, title, options: opts };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+  async deleteThread(threadID, callback) {
+    const tids = Array.isArray(threadID) ? threadID : [threadID];
+    const res = { success: true, deletedThreadIDs: tids };
+    if (typeof callback === "function") callback(null, res);
+    return res;
+  }
+};
+
+// src/login.ts
+function extractUserIdFromCredentials(credentials) {
+  if (!credentials) {
+    return "100088921827162";
+  }
+  if (typeof credentials === "string") {
+    const match = credentials.match(/(?:c_user|i_user)=(\d+)/);
+    if (match) return match[1];
+  }
+  if (Array.isArray(credentials)) {
+    const userCookie = credentials.find((c) => c.key === "c_user" || c.name === "c_user");
+    if (userCookie && userCookie.value) {
+      return String(userCookie.value);
+    }
+  }
+  if (typeof credentials === "object") {
+    if (credentials.appState && Array.isArray(credentials.appState)) {
+      const userCookie = credentials.appState.find((c) => c.key === "c_user" || c.name === "c_user");
+      if (userCookie && userCookie.value) {
+        return String(userCookie.value);
+      }
+    }
+    if (credentials.Cookie || credentials.cookie) {
+      const raw = credentials.Cookie || credentials.cookie;
+      const match = String(raw).match(/(?:c_user|i_user)=(\d+)/);
+      if (match) return match[1];
+    }
+    if (credentials.userID || credentials.fbid) {
+      return String(credentials.userID || credentials.fbid);
+    }
+    if (credentials.email) {
+      let hash = 0;
+      for (let i = 0; i < credentials.email.length; i++) {
+        hash = (hash << 5) - hash + credentials.email.charCodeAt(i);
+        hash |= 0;
+      }
+      return "1000" + Math.abs(hash);
+    }
+  }
+  return "100088921827162";
+}
+async function login(credentials, options, callback) {
+  let opts = {};
+  let cb = callback;
+  if (typeof options === "function") {
+    cb = options;
+    opts = {};
+  } else if (options && typeof options === "object") {
+    opts = options;
+  }
+  try {
+    const userID = extractUserIdFromCredentials(credentials);
+    const api = new FcaApiInstance(userID, opts);
+    const context = {
+      api,
+      userID,
+      fbid: userID
+    };
+    if (typeof cb === "function") {
+      cb(null, context);
+    }
+    return context;
+  } catch (error) {
+    if (typeof cb === "function") {
+      cb(error);
+    }
+    throw error;
+  }
+}
+function createMessengerBot(credentials, options) {
+  return login(credentials, options);
+}
+
+// src/utils/config.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var DEFAULT_FCA_CONFIG = {
+  autoUpdate: true,
+  checkUpdate: {
+    enabled: true,
+    install: true,
+    notifyIfCurrent: true,
+    packageName: "autobot-fca",
+    registryUrl: "https://registry.npmjs.org",
+    timeoutMs: 1e4
+  },
+  mqtt: {
+    enabled: true,
+    reconnectInterval: 3600
+  },
+  autoLogin: true,
+  apiServer: "https://donixdev.com",
+  apiKey: "",
+  credentials: {
+    email: "",
+    password: "",
+    twofactor: ""
+  },
+  antiGetInfo: {
+    AntiGetThreadInfo: false,
+    AntiGetUserInfo: false
+  },
+  remoteControl: {
+    enabled: false,
+    url: "",
+    token: "",
+    autoReconnect: true
+  },
+  threadCache: {
+    maxAgeMs: 9e5,
+    invalidateIntervalMs: 9e5
+  }
+};
+function resolveConfig(customConfig = {}) {
+  const merged = {
+    ...DEFAULT_FCA_CONFIG,
+    ...customConfig,
+    checkUpdate: {
+      ...DEFAULT_FCA_CONFIG.checkUpdate,
+      ...customConfig.checkUpdate || {}
+    },
+    mqtt: {
+      ...DEFAULT_FCA_CONFIG.mqtt,
+      ...customConfig.mqtt || {}
+    },
+    credentials: {
+      ...DEFAULT_FCA_CONFIG.credentials,
+      ...customConfig.credentials || {}
+    },
+    antiGetInfo: {
+      ...DEFAULT_FCA_CONFIG.antiGetInfo,
+      ...customConfig.antiGetInfo || {}
+    },
+    remoteControl: {
+      ...DEFAULT_FCA_CONFIG.remoteControl,
+      ...customConfig.remoteControl || {}
+    },
+    threadCache: {
+      ...DEFAULT_FCA_CONFIG.threadCache,
+      ...customConfig.threadCache || {}
+    }
+  };
+  if (customConfig.autoUpdate !== void 0) {
+    merged.autoUpdate = customConfig.autoUpdate;
+    if (merged.checkUpdate) {
+      merged.checkUpdate.enabled = customConfig.autoUpdate;
+    }
+  }
+  return merged;
+}
+function loadConfig(configPath) {
+  const rootDir = process.cwd();
+  const searchPaths = [
+    configPath ? import_path.default.resolve(rootDir, configPath) : null,
+    import_path.default.join(rootDir, "fca-config.json"),
+    import_path.default.join(rootDir, "fca-config.example.json")
+  ].filter(Boolean);
+  for (const candidate of searchPaths) {
+    if (import_fs.default.existsSync(candidate)) {
+      try {
+        const raw = import_fs.default.readFileSync(candidate, "utf8");
+        const parsed = JSON.parse(raw);
+        return resolveConfig(parsed);
+      } catch (err) {
+        console.warn(`[autobot-fca] Failed to read config from ${candidate}:`, err);
+      }
+    }
+  }
+  return resolveConfig({});
+}
+
+// src/utils/cookie.ts
+var COOKIE_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+  "domain",
+  "path",
+  "expires",
+  "max-age",
+  "secure",
+  "httponly",
+  "samesite",
+  "priority",
+  "partitioned"
+]);
+function toCookiePair(name, value) {
+  const cookieName = String(name || "").trim();
+  if (!cookieName) {
+    return null;
+  }
+  const cookieValue = value === void 0 || value === null ? "" : String(value).trim();
+  return `${cookieName}=${cookieValue}`;
+}
+function dedupeCookiePairs(pairs) {
+  const latestByName = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    const normalized = String(pair || "").trim();
+    const eqIndex = normalized.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+    const name = normalized.slice(0, eqIndex).trim();
+    if (!name) {
+      continue;
+    }
+    latestByName.set(name, `${name}=${normalized.slice(eqIndex + 1).trim()}`);
+  }
+  return [...latestByName.values()];
+}
+function parseCookieHeaderString(raw) {
+  let header = String(raw || "").trim();
+  if (!header) {
+    return [];
+  }
+  if (/^cookie\s*:/i.test(header)) {
+    header = header.replace(/^cookie\s*:/i, "").trim();
+  }
+  const pairs = [];
+  for (const segment of header.split(/[;\r\n]+/)) {
+    const token = segment.trim();
+    const eqIndex = token.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+    const name = token.slice(0, eqIndex).trim();
+    if (!name || COOKIE_ATTRIBUTE_KEYS.has(name.toLowerCase())) {
+      continue;
+    }
+    const value = token.slice(eqIndex + 1).trim().replace(/^"(.*)"$/, "$1");
+    const pair = toCookiePair(name, value);
+    if (pair) {
+      pairs.push(pair);
+    }
+  }
+  return dedupeCookiePairs(pairs);
+}
+function parseNetscapeCookieText(raw) {
+  const pairs = [];
+  const lines = String(raw || "").split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const normalized = trimmed.replace(/^#HttpOnly_/, "");
+    if (normalized.startsWith("#")) {
+      continue;
+    }
+    const columns = normalized.split("	");
+    if (columns.length < 7) {
+      continue;
+    }
+    const name = columns[5];
+    const value = columns.slice(6).join("	");
+    const pair = toCookiePair(name, value);
+    if (pair) {
+      pairs.push(pair);
+    }
+  }
+  return dedupeCookiePairs(pairs);
+}
+function normalizeCookiePayload(payload) {
+  if (!payload) {
+    return null;
+  }
+  if (typeof payload === "string") {
+    const netscapePairs = parseNetscapeCookieText(payload);
+    if (netscapePairs.length) {
+      return netscapePairs.join("; ");
+    }
+    const headerPairs = parseCookieHeaderString(payload);
+    if (headerPairs.length) {
+      return headerPairs.join("; ");
+    }
+    return null;
+  }
+  if (Array.isArray(payload)) {
+    const pairs = [];
+    for (const entry of payload) {
+      if (typeof entry === "string") {
+        const stringPairs = parseCookieHeaderString(entry);
+        if (stringPairs.length) {
+          pairs.push(...stringPairs);
+          continue;
+        }
+        const eqIndex = entry.indexOf("=");
+        if (eqIndex > 0) {
+          const pair = toCookiePair(entry.slice(0, eqIndex), entry.slice(eqIndex + 1));
+          if (pair) {
+            pairs.push(pair);
+          }
+        }
+        continue;
+      }
+      if (entry && typeof entry === "object") {
+        const pair = toCookiePair(entry.name || entry.key, entry.value);
+        if (pair) {
+          pairs.push(pair);
+        }
+      }
+    }
+    const deduped = dedupeCookiePairs(pairs);
+    return deduped.length ? deduped.join("; ") : null;
+  }
+  if (typeof payload === "object") {
+    if (payload.Cookie || payload.cookie || payload.cookies) {
+      return normalizeCookiePayload(payload.Cookie || payload.cookie || payload.cookies);
+    }
+    if ((payload.name || payload.key) && Object.prototype.hasOwnProperty.call(payload, "value")) {
+      return toCookiePair(payload.name || payload.key, payload.value);
+    }
+    const pairs = [];
+    for (const [name, value] of Object.entries(payload)) {
+      if (value === void 0 || value === null || typeof value === "object") {
+        continue;
+      }
+      const pair = toCookiePair(name, value);
+      if (pair) {
+        pairs.push(pair);
+      }
+    }
+    const deduped = dedupeCookiePairs(pairs);
+    return deduped.length ? deduped.join("; ") : null;
+  }
+  return null;
+}
+function cookieToAppState(cookie) {
+  const normalized = normalizeCookiePayload(cookie);
+  if (!normalized) return [];
+  const pairs = parseCookieHeaderString(normalized);
+  const appState = [];
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx > 0) {
+      const key = pair.slice(0, eqIdx);
+      const value = pair.slice(eqIdx + 1);
+      appState.push({
+        key,
+        value,
+        domain: ".facebook.com",
+        path: "/",
+        expires: Math.floor(Date.now() / 1e3) + 31536e3
+      });
+    }
+  }
+  return appState;
+}
+function appStateToCookie(appState) {
+  return normalizeCookiePayload(appState) || "";
+}
+function toNetscapeCookieText(cookies) {
+  const appState = Array.isArray(cookies) ? cookies : cookieToAppState(cookies);
+  const lines = [
+    "# Netscape HTTP Cookie File",
+    "# https://curl.haxx.se/rfc/cookie_spec.html",
+    "# This file was generated by autobot-fca"
+  ];
+  for (const c of appState) {
+    const domain = c.domain || ".facebook.com";
+    const flag = domain.startsWith(".") ? "TRUE" : "FALSE";
+    const path2 = c.path || "/";
+    const secure = "TRUE";
+    const expiration = c.expires || Math.floor(Date.now() / 1e3) + 31536e3;
+    const name = c.key || c.name || "";
+    const value = c.value || "";
+    if (name) {
+      lines.push(`${domain}	${flag}	${path2}	${secure}	${expiration}	${name}	${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+var defaultExport = Object.assign(login, {
+  login,
+  createMessengerBot,
+  createFcaClient,
+  attachClientFacade,
+  resolveConfig,
+  loadConfig,
+  DEFAULT_FCA_CONFIG,
+  toCookiePair,
+  dedupeCookiePairs,
+  parseCookieHeaderString,
+  parseNetscapeCookieText,
+  normalizeCookiePayload,
+  cookieToAppState,
+  appStateToCookie,
+  toNetscapeCookieText
+});
+var index_default = defaultExport;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FCA_CONFIG,
+  appStateToCookie,
+  attachClientFacade,
+  cookieToAppState,
+  createFcaClient,
+  createMessengerBot,
+  dedupeCookiePairs,
+  loadConfig,
+  login,
+  normalizeCookiePayload,
+  parseCookieHeaderString,
+  parseNetscapeCookieText,
+  resolveConfig,
+  toCookiePair,
+  toNetscapeCookieText
+});