meta-messenger.js 0.0.2 → 0.0.5

package/dist/index.js

@@ -0,0 +1,1098 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client.ts
+import { EventEmitter } from "events";
+
+// src/native.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import koffi from "koffi";
+function resolveDirname() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+__name(resolveDirname, "resolveDirname");
+function libPath() {
+  const base = path.join(resolveDirname(), "..", "build");
+  if (process.platform === "win32") return path.join(base, "messagix.dll");
+  if (process.platform === "darwin") return path.join(base, "messagix.dylib");
+  return path.join(base, "messagix.so");
+}
+__name(libPath, "libPath");
+var LIB_FILE = libPath();
+if (!fs.existsSync(LIB_FILE)) {
+  throw new Error(`Native library not found at ${LIB_FILE}. Run: npm run build:go`);
+}
+var lib = koffi.load(LIB_FILE);
+var mk = /* @__PURE__ */ __name((ret, name, args) => lib.func(name, ret, args), "mk");
+var fns = {
+  MxFreeCString: mk("void", "MxFreeCString", ["char*"]),
+  MxNewClient: mk("str", "MxNewClient", ["str"]),
+  MxConnect: mk("str", "MxConnect", ["str"]),
+  MxConnectE2EE: mk("str", "MxConnectE2EE", ["str"]),
+  MxDisconnect: mk("str", "MxDisconnect", ["str"]),
+  MxIsConnected: mk("str", "MxIsConnected", ["str"]),
+  MxSendMessage: mk("str", "MxSendMessage", ["str"]),
+  MxSendReaction: mk("str", "MxSendReaction", ["str"]),
+  MxEditMessage: mk("str", "MxEditMessage", ["str"]),
+  MxUnsendMessage: mk("str", "MxUnsendMessage", ["str"]),
+  MxSendTyping: mk("str", "MxSendTyping", ["str"]),
+  MxMarkRead: mk("str", "MxMarkRead", ["str"]),
+  MxUploadMedia: mk("str", "MxUploadMedia", ["str"]),
+  MxSendImage: mk("str", "MxSendImage", ["str"]),
+  MxSendVideo: mk("str", "MxSendVideo", ["str"]),
+  MxSendVoice: mk("str", "MxSendVoice", ["str"]),
+  MxSendFile: mk("str", "MxSendFile", ["str"]),
+  MxSendSticker: mk("str", "MxSendSticker", ["str"]),
+  MxCreateThread: mk("str", "MxCreateThread", ["str"]),
+  MxGetUserInfo: mk("str", "MxGetUserInfo", ["str"]),
+  MxSetGroupPhoto: mk("str", "MxSetGroupPhoto", ["str"]),
+  MxRenameThread: mk("str", "MxRenameThread", ["str"]),
+  MxMuteThread: mk("str", "MxMuteThread", ["str"]),
+  MxDeleteThread: mk("str", "MxDeleteThread", ["str"]),
+  MxSearchUsers: mk("str", "MxSearchUsers", ["str"]),
+  MxPollEvents: mk("str", "MxPollEvents", ["str"]),
+  MxSendE2EEMessage: mk("str", "MxSendE2EEMessage", ["str"]),
+  MxSendE2EEReaction: mk("str", "MxSendE2EEReaction", ["str"]),
+  MxSendE2EETyping: mk("str", "MxSendE2EETyping", ["str"]),
+  MxEditE2EEMessage: mk("str", "MxEditE2EEMessage", ["str"]),
+  MxUnsendE2EEMessage: mk("str", "MxUnsendE2EEMessage", ["str"]),
+  MxGetDeviceData: mk("str", "MxGetDeviceData", ["str"]),
+  // E2EE Media functions
+  MxSendE2EEImage: mk("str", "MxSendE2EEImage", ["str"]),
+  MxSendE2EEVideo: mk("str", "MxSendE2EEVideo", ["str"]),
+  MxSendE2EEAudio: mk("str", "MxSendE2EEAudio", ["str"]),
+  MxSendE2EEDocument: mk("str", "MxSendE2EEDocument", ["str"]),
+  MxSendE2EESticker: mk("str", "MxSendE2EESticker", ["str"])
+};
+function call(fn, payload) {
+  const input = JSON.stringify(payload);
+  const bound = fns[fn];
+  const out = bound(input);
+  const data = JSON.parse(out);
+  if (!data.ok) throw new Error(data.error || "Unknown error");
+  return data.data;
+}
+__name(call, "call");
+function callAsync(fn, payload) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      try {
+        const result = call(fn, payload);
+        resolve(result);
+      } catch (err) {
+        reject(err);
+      }
+    }, 0);
+  });
+}
+__name(callAsync, "callAsync");
+var native = {
+  newClient: /* @__PURE__ */ __name((cfg) => call("MxNewClient", cfg), "newClient"),
+  connect: /* @__PURE__ */ __name((handle) => call("MxConnect", { handle }), "connect"),
+  connectE2EE: /* @__PURE__ */ __name((handle) => callAsync("MxConnectE2EE", { handle }), "connectE2EE"),
+  disconnect: /* @__PURE__ */ __name((handle) => call("MxDisconnect", { handle }), "disconnect"),
+  isConnected: /* @__PURE__ */ __name((handle) => call("MxIsConnected", { handle }), "isConnected"),
+  sendMessage: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendMessage", { handle, options }), "sendMessage"),
+  sendReaction: /* @__PURE__ */ __name((handle, threadId, messageId, emoji) => callAsync("MxSendReaction", { handle, threadId, messageId, emoji }), "sendReaction"),
+  editMessage: /* @__PURE__ */ __name((handle, messageId, newText) => callAsync("MxEditMessage", { handle, messageId, newText }), "editMessage"),
+  unsendMessage: /* @__PURE__ */ __name((handle, messageId) => callAsync("MxUnsendMessage", { handle, messageId }), "unsendMessage"),
+  sendTyping: /* @__PURE__ */ __name((handle, threadId, isTyping, isGroup, threadType) => callAsync("MxSendTyping", { handle, threadId, isTyping, isGroup, threadType }), "sendTyping"),
+  markRead: /* @__PURE__ */ __name((handle, threadId, watermarkTs) => callAsync("MxMarkRead", { handle, threadId, watermarkTs: watermarkTs || 0 }), "markRead"),
+  uploadMedia: /* @__PURE__ */ __name((handle, options) => callAsync("MxUploadMedia", { handle, options }), "uploadMedia"),
+  sendImage: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendImage", { handle, options }), "sendImage"),
+  sendVideo: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendVideo", { handle, options }), "sendVideo"),
+  sendVoice: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendVoice", { handle, options }), "sendVoice"),
+  sendFile: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendFile", { handle, options }), "sendFile"),
+  sendSticker: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendSticker", { handle, options }), "sendSticker"),
+  createThread: /* @__PURE__ */ __name((handle, options) => callAsync("MxCreateThread", { handle, options }), "createThread"),
+  getUserInfo: /* @__PURE__ */ __name((handle, options) => callAsync("MxGetUserInfo", { handle, options }), "getUserInfo"),
+  setGroupPhoto: /* @__PURE__ */ __name((handle, threadId, data, mimeType) => callAsync("MxSetGroupPhoto", { handle, threadId, data, mimeType }), "setGroupPhoto"),
+  renameThread: /* @__PURE__ */ __name((handle, options) => callAsync("MxRenameThread", { handle, options }), "renameThread"),
+  muteThread: /* @__PURE__ */ __name((handle, options) => callAsync("MxMuteThread", { handle, options }), "muteThread"),
+  deleteThread: /* @__PURE__ */ __name((handle, options) => callAsync("MxDeleteThread", { handle, options }), "deleteThread"),
+  searchUsers: /* @__PURE__ */ __name((handle, options) => callAsync("MxSearchUsers", {
+    handle,
+    options
+  }), "searchUsers"),
+  pollEvents: /* @__PURE__ */ __name((handle, timeoutMs) => callAsync("MxPollEvents", { handle, timeoutMs }), "pollEvents"),
+  // E2EE functions
+  sendE2EEMessage: /* @__PURE__ */ __name((handle, chatJid, text, replyToId, replyToSenderJid) => callAsync("MxSendE2EEMessage", {
+    handle,
+    chatJid,
+    text,
+    replyToId,
+    replyToSenderJid
+  }), "sendE2EEMessage"),
+  sendE2EEReaction: /* @__PURE__ */ __name((handle, chatJid, messageId, senderJid, emoji) => callAsync("MxSendE2EEReaction", { handle, chatJid, messageId, senderJid, emoji }), "sendE2EEReaction"),
+  sendE2EETyping: /* @__PURE__ */ __name((handle, chatJid, isTyping) => callAsync("MxSendE2EETyping", { handle, chatJid, isTyping }), "sendE2EETyping"),
+  editE2EEMessage: /* @__PURE__ */ __name((handle, chatJid, messageId, newText) => callAsync("MxEditE2EEMessage", { handle, chatJid, messageId, newText }), "editE2EEMessage"),
+  unsendE2EEMessage: /* @__PURE__ */ __name((handle, chatJid, messageId) => callAsync("MxUnsendE2EEMessage", { handle, chatJid, messageId }), "unsendE2EEMessage"),
+  getDeviceData: /* @__PURE__ */ __name((handle) => call("MxGetDeviceData", { handle }), "getDeviceData"),
+  // E2EE Media functions
+  sendE2EEImage: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendE2EEImage", { handle, options }), "sendE2EEImage"),
+  sendE2EEVideo: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendE2EEVideo", { handle, options }), "sendE2EEVideo"),
+  sendE2EEAudio: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendE2EEAudio", { handle, options }), "sendE2EEAudio"),
+  sendE2EEDocument: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendE2EEDocument", { handle, options }), "sendE2EEDocument"),
+  sendE2EESticker: /* @__PURE__ */ __name((handle, options) => callAsync("MxSendE2EESticker", { handle, options }), "sendE2EESticker"),
+  unload: /* @__PURE__ */ __name(() => lib.unload(), "unload")
+};
+
+// src/client.ts
+var Client = class extends EventEmitter {
+  static {
+    __name(this, "Client");
+  }
+  handle = null;
+  options;
+  cookies;
+  _user = null;
+  _initialData = null;
+  eventLoopRunning = false;
+  eventLoopAbort = null;
+  _socketReady = false;
+  _e2eeConnected = false;
+  _fullyReadyEmitted = false;
+  pendingEvents = [];
+  /**
+   * Create a new Messenger client
+   *
+   * @param cookies - Authentication cookies
+   * @param options - Client options
+   */
+  constructor(cookies, options = {}) {
+    super();
+    this.cookies = cookies;
+    this.options = {
+      // ! todo: detect platform automatically
+      platform: "facebook",
+      logLevel: "none",
+      enableE2EE: true,
+      autoReconnect: true,
+      ...options
+    };
+  }
+  /**
+   * Get the current user info
+   */
+  get user() {
+    return this._user;
+  }
+  /**
+   * Get the current user's Facebook ID
+   */
+  get currentUserId() {
+    return this._user?.id ?? null;
+  }
+  /**
+   * Get initial sync data (threads and messages)
+   */
+  get initialData() {
+    return this._initialData;
+  }
+  /**
+   * Check if client is fully ready (socket ready + E2EE connected if enabled)
+   */
+  get isFullyReady() {
+    if (!this._socketReady) return false;
+    if (this.options.enableE2EE && !this._e2eeConnected) return false;
+    return true;
+  }
+  /**
+   * Check if client is connected
+   */
+  get isConnected() {
+    if (!this.handle) return false;
+    try {
+      const status = native.isConnected(this.handle);
+      return status.connected;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if E2EE is connected
+   */
+  get isE2EEConnected() {
+    if (!this.handle) return false;
+    try {
+      const status = native.isConnected(this.handle);
+      return status.e2eeConnected;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Connect to Messenger
+   *
+   * @returns User info and initial data
+   */
+  async connect() {
+    const { handle } = native.newClient({
+      cookies: this.cookies,
+      platform: this.options.platform,
+      devicePath: this.options.devicePath,
+      deviceData: this.options.deviceData,
+      logLevel: this.options.logLevel
+    });
+    this.handle = handle;
+    const result = native.connect(handle);
+    this._user = result.user;
+    this._initialData = result.initialData;
+    this.startEventLoop();
+    if (this.options.enableE2EE) {
+      this.connectE2EE().catch((err) => {
+        this.emit("error", err);
+      });
+    }
+    return {
+      user: this._user,
+      initialData: this._initialData
+    };
+  }
+  /**
+   * Connect E2EE (end-to-end encryption)
+   * @warn This Promise is not resolved after the connection setup is completed; instead, it is resolved after the function finishes executing.\
+   * You should not rely on this Promise to wait for the E2EE connection to be fully established.
+   */
+  async connectE2EE() {
+    if (!this.handle) throw new Error("Not connected");
+    await native.connectE2EE(this.handle);
+  }
+  /**
+   * Disconnect from Messenger
+   */
+  async disconnect() {
+    this.stopEventLoop();
+    if (this.handle) {
+      native.disconnect(this.handle);
+      this.handle = null;
+    }
+  }
+  /**
+   * Send a text message
+   *
+   * @param threadId - Thread ID to send to
+   * @param options - Message options (text, reply, mentions)
+   * @returns Send result with message ID
+   */
+  async sendMessage(threadId, options) {
+    if (!this.handle) throw new Error("Not connected");
+    const opts = typeof options === "string" ? { text: options } : options;
+    return native.sendMessage(this.handle, {
+      threadId,
+      text: opts.text,
+      replyToId: opts.replyToId,
+      mentionIds: opts.mentions?.map((m) => m.userId),
+      mentionOffsets: opts.mentions?.map((m) => m.offset),
+      mentionLengths: opts.mentions?.map((m) => m.length)
+    });
+  }
+  /**
+   * Send / Remove a reaction to a message
+   *
+   * @param threadId - Thread ID
+   * @param messageId - Message ID to react to
+   * @param emoji - Reaction emoji (to remove, simply omit this parameter)
+   */
+  async sendReaction(threadId, messageId, emoji) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.sendReaction(this.handle, threadId, messageId, emoji || "");
+  }
+  /**
+   * Edit a message
+   *
+   * @param messageId - Message ID to edit
+   * @param newText - New text content
+   */
+  async editMessage(messageId, newText) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.editMessage(this.handle, messageId, newText);
+  }
+  /**
+   * Unsend/delete a message
+   *
+   * @param messageId - Message ID to unsend
+   */
+  async unsendMessage(messageId) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.unsendMessage(this.handle, messageId);
+  }
+  /**
+   * Send typing indicator
+   *
+   * @param threadId - Thread ID
+   * @param isTyping - Whether typing or not
+   * @param isGroup - Whether it's a group chat
+   */
+  async sendTypingIndicator(threadId, isTyping = true, isGroup = false) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.sendTyping(this.handle, threadId, isTyping, isGroup, isGroup ? 2 : 1);
+  }
+  /**
+   * Mark messages as read
+   *
+   * @param threadId - Thread ID
+   * @param watermarkTs - Timestamp to mark read up to (optional)
+   */
+  async markAsRead(threadId, watermarkTs) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.markRead(this.handle, threadId, watermarkTs);
+  }
+  /**
+   * Upload media to Messenger
+   *
+   * @param threadId - Thread ID
+   * @param data - File data as Buffer
+   * @param filename - Filename
+   * @param mimeType - MIME type
+   * @param isVoice - Whether it's a voice message
+   * @returns Upload result with Facebook ID
+   */
+  async uploadMedia(threadId, data, filename, mimeType, isVoice = false) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.uploadMedia(this.handle, {
+      threadId,
+      filename,
+      mimeType,
+      data: Array.from(data),
+      isVoice
+    });
+  }
+  /**
+   * Send an image
+   *
+   * @param threadId - Thread ID
+   * @param data - Image data as Buffer
+   * @param filename - Filename
+   * @param caption - Optional caption
+   */
+  async sendImage(threadId, data, filename, caption) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendImage(this.handle, {
+      threadId,
+      data: Array.from(data),
+      filename,
+      caption
+    });
+  }
+  /**
+   * Send a video
+   *
+   * @param threadId - Thread ID
+   * @param data - Video data as Buffer
+   * @param filename - Filename
+   * @param caption - Optional caption
+   */
+  async sendVideo(threadId, data, filename, caption) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendVideo(this.handle, {
+      threadId,
+      data: Array.from(data),
+      filename,
+      caption
+    });
+  }
+  /**
+   * Send a voice message
+   *
+   * @param threadId - Thread ID
+   * @param data - Audio data as Buffer
+   * @param filename - Filename
+   */
+  async sendVoice(threadId, data, filename) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendVoice(this.handle, {
+      threadId,
+      data: Array.from(data),
+      filename
+    });
+  }
+  /**
+   * Send a file
+   *
+   * @param threadId - Thread ID
+   * @param data - File data as Buffer
+   * @param filename - Filename
+   * @param mimeType - MIME type
+   * @param caption - Optional caption
+   */
+  async sendFile(threadId, data, filename, mimeType, caption) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendFile(this.handle, {
+      threadId,
+      data: Array.from(data),
+      filename,
+      mimeType,
+      caption
+    });
+  }
+  /**
+   * Send a sticker
+   *
+   * @param threadId - Thread ID
+   * @param stickerId - Sticker ID
+   */
+  async sendSticker(threadId, stickerId) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendSticker(this.handle, { threadId, stickerId });
+  }
+  /**
+   * Create a 1:1 thread with a user
+   *
+   * @param userId - User ID to create thread with
+   * @returns Created thread info
+   */
+  async createThread(userId) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.createThread(this.handle, { userId });
+  }
+  /**
+   * Get detailed information about a user
+   *
+   * @param userId - User ID
+   * @returns User info
+   */
+  async getUserInfo(userId) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.getUserInfo(this.handle, { userId });
+  }
+  /**
+   * Set group photo/avatar
+   *
+   * @param threadId - Thread ID
+   * @param data - Image data as Buffer or base64 string
+   * @param mimeType - MIME type (e.g., 'image/jpeg', 'image/png')
+   *
+   * @warn Cannot remove group photo. Messenger web doesn't have a remove option?
+   */
+  async setGroupPhoto(threadId, data, mimeType = "image/jpeg") {
+    if (!this.handle) throw new Error("Not connected");
+    const base64 = Buffer.isBuffer(data) ? data.toString("base64") : data;
+    await native.setGroupPhoto(this.handle, threadId, base64, mimeType);
+  }
+  /**
+   * Rename a group thread
+   *
+   * @param threadId - Thread ID
+   * @param newName - New name
+   */
+  async renameThread(threadId, newName) {
+    if (!this.handle) throw new Error("Not connected");
+    native.renameThread(this.handle, { threadId, newName });
+  }
+  /**
+   * Mute a thread
+   *
+   * @param threadId - Thread ID
+   * @param muteSeconds - Duration in seconds (-1 for forever, 0 to unmute)
+   */
+  async muteThread(threadId, muteSeconds = -1) {
+    if (!this.handle) throw new Error("Not connected");
+    native.muteThread(this.handle, { threadId, muteSeconds });
+  }
+  /**
+   * Unmute a thread
+   *
+   * @param threadId - Thread ID
+   */
+  async unmuteThread(threadId) {
+    return this.muteThread(threadId, 0);
+  }
+  /**
+   * Delete a thread
+   *
+   * @param threadId - Thread ID
+   */
+  async deleteThread(threadId) {
+    if (!this.handle) throw new Error("Not connected");
+    native.deleteThread(this.handle, { threadId });
+  }
+  /**
+   * Search for users
+   *
+   * @param query - Search query
+   * @returns List of matching users
+   */
+  async searchUsers(query) {
+    if (!this.handle) throw new Error("Not connected");
+    const result = await native.searchUsers(this.handle, { query });
+    return result.users;
+  }
+  // ========== E2EE Methods ==========
+  /**
+   * Send an E2EE message
+   *
+   * @param chatJid - Chat JID
+   * @param text - Message text
+   * @param options - Optional: replyToId and replyToSenderJid for replies
+   */
+  async sendE2EEMessage(chatJid, text, options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EEMessage(this.handle, chatJid, text, options?.replyToId, options?.replyToSenderJid);
+  }
+  /**
+   * Send / Remove an E2EE reaction
+   *
+   * @param chatJid - Chat JID
+   * @param messageId - Message ID
+   * @param senderJid - Sender JID
+   * @param emoji - Reaction emoji (To remove it, simply omit this parameter)
+   */
+  async sendE2EEReaction(chatJid, messageId, senderJid, emoji) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.sendE2EEReaction(this.handle, chatJid, messageId, senderJid, emoji || "");
+  }
+  /**
+   * Send E2EE typing indicator
+   *
+   * @param chatJid - Chat JID
+   * @param isTyping - Whether typing
+   */
+  async sendE2EETyping(chatJid, isTyping = true) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.sendE2EETyping(this.handle, chatJid, isTyping);
+  }
+  /**
+   * Edit an E2EE message
+   *
+   * @param chatJid - Chat JID
+   * @param messageId - Message ID to edit
+   * @param newText - New message text
+   */
+  async editE2EEMessage(chatJid, messageId, newText) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.editE2EEMessage(this.handle, chatJid, messageId, newText);
+  }
+  /**
+   * Unsend/delete an E2EE message
+   *
+   * @param chatJid - Chat JID
+   * @param messageId - Message ID to unsend
+   */
+  async unsendE2EEMessage(chatJid, messageId) {
+    if (!this.handle) throw new Error("Not connected");
+    await native.unsendE2EEMessage(this.handle, chatJid, messageId);
+  }
+  // ========== E2EE Media Methods ==========
+  /**
+   * Send an E2EE image
+   *
+   * @param chatJid - Chat JID
+   * @param data - Image data as Buffer
+   * @param mimeType - MIME type (e.g., image/jpeg, image/png)
+   * @param options - Optional caption, dimensions, and reply options
+   */
+  async sendE2EEImage(chatJid, data, mimeType = "image/jpeg", options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EEImage(this.handle, {
+      chatJid,
+      data: Array.from(data),
+      mimeType,
+      caption: options?.caption,
+      width: options?.width,
+      height: options?.height,
+      replyToId: options?.replyToId,
+      replyToSenderJid: options?.replyToSenderJid
+    });
+  }
+  /**
+   * Send an E2EE video
+   *
+   * @param chatJid - Chat JID
+   * @param data - Video data as Buffer
+   * @param mimeType - MIME type (default: video/mp4)
+   * @param options - Optional caption, dimensions, duration, and reply options
+   */
+  async sendE2EEVideo(chatJid, data, mimeType = "video/mp4", options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EEVideo(this.handle, {
+      chatJid,
+      data: Array.from(data),
+      mimeType,
+      caption: options?.caption,
+      width: options?.width,
+      height: options?.height,
+      duration: options?.duration,
+      replyToId: options?.replyToId,
+      replyToSenderJid: options?.replyToSenderJid
+    });
+  }
+  /**
+   * Send an E2EE audio/voice message
+   *
+   * @param chatJid - Chat JID
+   * @param data - Audio data as Buffer
+   * @param mimeType - MIME type (default: audio/ogg)
+   * @param options - Optional PTT (push-to-talk/voice message), duration, and reply options
+   */
+  async sendE2EEAudio(chatJid, data, mimeType = "audio/ogg", options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EEAudio(this.handle, {
+      chatJid,
+      data: Array.from(data),
+      mimeType,
+      ptt: options?.ptt ?? false,
+      duration: options?.duration,
+      replyToId: options?.replyToId,
+      replyToSenderJid: options?.replyToSenderJid
+    });
+  }
+  /**
+   * Send an E2EE document/file
+   *
+   * @param chatJid - Chat JID
+   * @param data - File data as Buffer
+   * @param filename - Filename
+   * @param mimeType - MIME type
+   * @param options - Optional reply options
+   */
+  async sendE2EEDocument(chatJid, data, filename, mimeType, options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EEDocument(this.handle, {
+      chatJid,
+      data: Array.from(data),
+      filename,
+      mimeType,
+      replyToId: options?.replyToId,
+      replyToSenderJid: options?.replyToSenderJid
+    });
+  }
+  /**
+   * Send an E2EE sticker
+   *
+   * @param chatJid - Chat JID
+   * @param data - Sticker data as Buffer (WebP format)
+   * @param mimeType - MIME type (default: image/webp)
+   * @param options - Optional reply options
+   */
+  async sendE2EESticker(chatJid, data, mimeType = "image/webp", options) {
+    if (!this.handle) throw new Error("Not connected");
+    return native.sendE2EESticker(this.handle, {
+      chatJid,
+      data: Array.from(data),
+      mimeType,
+      replyToId: options?.replyToId,
+      replyToSenderJid: options?.replyToSenderJid
+    });
+  }
+  /**
+   * Get E2EE device data as JSON string
+   *
+   * Use this to persist device data externally (e.g., in a database)
+   *
+   * @returns Device data as JSON string
+   */
+  getDeviceData() {
+    if (!this.handle) throw new Error("Not connected");
+    const result = native.getDeviceData(this.handle);
+    return result.deviceData;
+  }
+  startEventLoop() {
+    if (this.eventLoopRunning) return;
+    this.eventLoopRunning = true;
+    this.eventLoopAbort = new AbortController();
+    const loop = /* @__PURE__ */ __name(async () => {
+      while (this.eventLoopRunning && this.handle) {
+        try {
+          await new Promise((resolve) => setImmediate(resolve));
+          const event = await native.pollEvents(this.handle, 1e3);
+          if (!event || event.type === "timeout") continue;
+          if (event.type === "closed") {
+            this.eventLoopRunning = false;
+            break;
+          }
+          this.handleEvent(event);
+        } catch (err) {
+          if (this.eventLoopRunning) {
+            this.emit("error", err);
+          }
+        }
+      }
+    }, "loop");
+    setImmediate(loop).unref();
+  }
+  stopEventLoop() {
+    this.eventLoopRunning = false;
+    this.eventLoopAbort?.abort();
+    this.eventLoopAbort = null;
+  }
+  checkFullyReady() {
+    if (this.isFullyReady && !this._fullyReadyEmitted) {
+      this._fullyReadyEmitted = true;
+      this.emit("fullyReady");
+      const pending = this.pendingEvents;
+      this.pendingEvents = [];
+      for (const event of pending) {
+        this.emitEvent(event);
+      }
+    }
+  }
+  handleEvent(event) {
+    switch (event.type) {
+      // System events
+      case "ready":
+        this._socketReady = true;
+        this.emit("ready", event.data);
+        this.checkFullyReady();
+        break;
+      case "reconnected":
+        this.emit("reconnected");
+        break;
+      case "disconnected":
+        this._socketReady = false;
+        this._e2eeConnected = false;
+        this._fullyReadyEmitted = false;
+        this.pendingEvents = [];
+        this.emit("disconnected", event.data || {});
+        break;
+      case "error":
+        this.emit("error", new Error(event.data.message));
+        break;
+      case "e2eeConnected":
+        this._e2eeConnected = true;
+        this.emit("e2eeConnected");
+        this.checkFullyReady();
+        break;
+      case "deviceDataChanged":
+        this.emit("deviceDataChanged", event.data);
+        break;
+      // queue until fullyReady
+      case "message":
+      case "messageEdit":
+      case "messageUnsend":
+      case "reaction":
+      case "typing":
+      case "readReceipt":
+      case "e2eeMessage":
+      case "e2eeReaction":
+      case "e2eeReceipt":
+        if (this._fullyReadyEmitted) {
+          this.emitEvent(event);
+        } else {
+          this.pendingEvents.push(event);
+        }
+        break;
+    }
+  }
+  emitEvent(event) {
+    switch (event.type) {
+      case "message":
+        this.emit("message", event.data);
+        break;
+      case "messageEdit":
+        this.emit("messageEdit", event.data);
+        break;
+      case "messageUnsend":
+        this.emit("messageUnsend", event.data);
+        break;
+      case "reaction":
+        this.emit("reaction", event.data);
+        break;
+      case "typing":
+        this.emit("typing", event.data);
+        break;
+      case "readReceipt":
+        this.emit("readReceipt", event.data);
+        break;
+      case "e2eeMessage":
+        this.emit("e2eeMessage", event.data);
+        break;
+      case "e2eeReaction":
+        this.emit("e2eeReaction", event.data);
+        break;
+      case "e2eeReceipt":
+        this.emit("e2eeReceipt", event.data);
+        break;
+    }
+  }
+  /**
+   * Unload the native library (for cleanup)
+   * @warn Any attempt to find or call a function from this library after unloading it will crash.
+   * @returns void
+   */
+  unloadLibrary() {
+    if (this.handle) {
+      native.unload();
+    }
+  }
+};
+
+// src/types.ts
+var ThreadType = /* @__PURE__ */ ((ThreadType2) => {
+  ThreadType2[ThreadType2["ONE_TO_ONE"] = 1] = "ONE_TO_ONE";
+  ThreadType2[ThreadType2["GROUP"] = 2] = "GROUP";
+  ThreadType2[ThreadType2["PAGE"] = 3] = "PAGE";
+  ThreadType2[ThreadType2["MARKETPLACE"] = 4] = "MARKETPLACE";
+  ThreadType2[ThreadType2["ENCRYPTED_ONE_TO_ONE"] = 7] = "ENCRYPTED_ONE_TO_ONE";
+  ThreadType2[ThreadType2["ENCRYPTED_GROUP"] = 8] = "ENCRYPTED_GROUP";
+  return ThreadType2;
+})(ThreadType || {});
+
+// src/utils.ts
+var Utils = class _Utils extends null {
+  static {
+    __name(this, "Utils");
+  }
+  /**
+   * Parse cookies from various formats
+   * Automatically detects the format and parses accordingly
+   *
+   * @param input - Cookie data in any supported format
+   * @returns Parsed cookies object
+   */
+  static parseCookies(input) {
+    if (typeof input === "object" && !Array.isArray(input)) {
+      return input;
+    }
+    if (Array.isArray(input)) {
+      return _Utils.fromCookieArray(input);
+    }
+    if (typeof input === "string") {
+      const trimmed = input.trim();
+      if (_Utils.isBase64(trimmed)) {
+        try {
+          const decoded = Buffer.from(trimmed, "base64").toString("utf-8");
+          return _Utils.parseCookies(decoded);
+        } catch {
+        }
+      }
+      if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        try {
+          const parsed = JSON.parse(trimmed);
+          return _Utils.parseCookies(parsed);
+        } catch {
+        }
+      }
+      if (trimmed.includes("	") && (trimmed.startsWith("#") || trimmed.includes(".facebook.com") || trimmed.includes(".messenger.com"))) {
+        return _Utils.fromNetscape(trimmed);
+      }
+      if (trimmed.includes("=")) {
+        return _Utils.fromCookieString(trimmed);
+      }
+    }
+    throw new Error("Unable to parse cookies: unknown format");
+  }
+  /**
+   * Parse cookies from C3C UFC Utility / EditThisCookie array format
+   *
+   * @param cookies - Array of cookie objects
+   * @returns Parsed cookies object
+   *
+   * @example
+   * ```typescript
+   * const cookies = Utils.fromCookieArray([
+   *     { name: 'c_user', value: '123456' },
+   *     { name: 'xs', value: 'abc...' }
+   * ])
+   * ```
+   */
+  static fromCookieArray(cookies) {
+    const result = {};
+    for (const cookie of cookies) {
+      if (cookie.name && cookie.value !== void 0) {
+        result[cookie.name] = String(cookie.value);
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse cookies from cookie header string format
+   *
+   * @param cookieString - Cookie string (e.g., "name1=value1; name2=value2")
+   * @returns Parsed cookies object
+   *
+   * @example
+   * ```typescript
+   * const cookies = Utils.fromCookieString('c_user=123456; xs=abc...; datr=xyz...')
+   * ```
+   */
+  static fromCookieString(cookieString) {
+    const result = {};
+    const pairs = cookieString.split(/;\s*/);
+    for (const pair of pairs) {
+      const [name, ...valueParts] = pair.split("=");
+      if (name && valueParts.length > 0) {
+        const trimmedName = name.trim();
+        const value = valueParts.join("=").trim();
+        if (trimmedName && value) {
+          result[trimmedName] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse cookies from Netscape/HTTP cookie file format
+   *
+   * @param content - Netscape cookie file content
+   * @returns Parsed cookies object
+   *
+   * @example
+   * ```typescript
+   * const cookies = Utils.fromNetscape(`
+   * # Netscape HTTP Cookie File
+   * .facebook.com	TRUE	/	TRUE	1234567890	c_user	123456
+   * .facebook.com	TRUE	/	TRUE	1234567890	xs	abc...
+   * `)
+   * ```
+   */
+  static fromNetscape(content) {
+    const result = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const parts = trimmed.split("	");
+      if (parts.length >= 7) {
+        const name = parts[5];
+        const value = parts[6];
+        if (name && value) {
+          result[name] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse cookies from Base64 encoded string
+   *
+   * @param base64 - Base64 encoded cookie data
+   * @returns Parsed cookies object
+   */
+  static fromBase64(base64) {
+    const decoded = Buffer.from(base64, "base64").toString("utf-8");
+    return _Utils.parseCookies(decoded);
+  }
+  /**
+   * Convert cookies object to cookie header string
+   *
+   * @param cookies - Cookies object
+   * @returns Cookie header string
+   *
+   * @example
+   * ```typescript
+   * const header = Utils.toCookieString({ c_user: '123456', xs: 'abc...' })
+   * // Returns: "c_user=123456; xs=abc..."
+   * ```
+   */
+  static toCookieString(cookies) {
+    return Object.entries(cookies).map(([name, value]) => `${name}=${value}`).join("; ");
+  }
+  /**
+   * Convert cookies object to array format (C3C UFC Utility style)
+   *
+   * @param cookies - Cookies object
+   * @param domain - Cookie domain (default: .facebook.com)
+   * @returns Array of cookie objects
+   *
+   * @example
+   * ```typescript
+   * const arr = Utils.toCookieArray({ c_user: '123456', xs: 'abc...' })
+   * ```
+   */
+  static toCookieArray(cookies, domain = ".facebook.com") {
+    return Object.entries(cookies).filter(([, value]) => value !== void 0).map(([name, value]) => ({
+      name,
+      value,
+      domain,
+      path: "/",
+      secure: true,
+      httpOnly: true
+    }));
+  }
+  /**
+   * Convert cookies object to Netscape format
+   *
+   * @param cookies - Cookies object
+   * @param domain - Cookie domain (default: .facebook.com)
+   * @returns Netscape cookie file content
+   */
+  static toNetscape(cookies, domain = ".facebook.com") {
+    const lines = ["# Netscape HTTP Cookie File", "# Generated by meta-messenger.js", ""];
+    for (const [name, value] of Object.entries(cookies)) {
+      const expiration = Math.floor(Date.now() / 1e3) + 365 * 24 * 60 * 60;
+      lines.push(`${domain}	TRUE	/	TRUE	${expiration}	${name}	${value}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Convert cookies to Base64 encoded JSON
+   *
+   * @param cookies - Cookies object
+   * @returns Base64 encoded string
+   */
+  static toBase64(cookies) {
+    return Buffer.from(JSON.stringify(cookies)).toString("base64");
+  }
+  /**
+   * Filter cookies to only essential ones for Facebook/Messenger
+   *
+   * @param cookies - Cookies object
+   * @returns Filtered cookies with only essential keys
+   */
+  static filterEssential(cookies) {
+    const essential = ["c_user", "xs", "datr", "fr", "sb", "wd", "presence"];
+    const result = {};
+    for (const key of essential) {
+      if (cookies[key]) {
+        result[key] = cookies[key];
+      }
+    }
+    return result;
+  }
+  /**
+   * Validate that cookies contain required fields
+   *
+   * @param cookies - Cookies object
+   * @returns True if cookies are valid
+   */
+  static validate(cookies) {
+    const required = ["c_user", "xs"];
+    return required.every((key) => cookies[key] && cookies[key].length > 0);
+  }
+  /**
+   * Get missing required cookies
+   *
+   * @param cookies - Cookies object
+   * @returns Array of missing cookie names
+   */
+  static getMissing(cookies) {
+    const required = ["c_user", "xs"];
+    return required.filter((key) => !cookies[key] || cookies[key].length === 0);
+  }
+  /**
+   * Check if a string is valid Base64
+   */
+  static isBase64(str) {
+    if (str.length < 4) return false;
+    const base64Regex = /^[A-Za-z0-9+/]+=*$/;
+    if (!base64Regex.test(str)) return false;
+    return str.length > 20 && str.length % 4 === 0;
+  }
+};
+
+// src/index.ts
+async function login(cookies, options) {
+  const client = new Client(cookies, options);
+  await client.connect();
+  return client;
+}
+__name(login, "login");
+function createClient(cookies, options) {
+  return new Client(cookies, options);
+}
+__name(createClient, "createClient");
+var index_default = { Client, login, createClient };
+export {
+  Client,
+  ThreadType,
+  Utils,
+  createClient,
+  index_default as default,
+  login
+};
+//# sourceMappingURL=index.js.map