fb-messenger-e2ee 0.1.3 → 0.1.5

package/DOCS.md

@@ -217,6 +217,47 @@ await client.sendImage({
 });
 ```
 
+### `sendFiles`
+
+Sends multiple files/attachments in a single call.
+
+- **Non-E2EE threads**: Bundles all files into a single Messenger message containing multiple attachments.
+- **E2EE threads**: Since the Messenger E2EE transport protocol does not support multi-attachment payloads in a single encrypted frame, the attachments are sent sequentially as separate encrypted messages. Optional fields like `caption` and `replyToMessageId` are only applied to the first attachment.
+
+Returns either a single result object (for non-E2EE) or an array of result objects (one per attachment for E2EE).
+
+```typescript
+await client.sendFiles({
+  threadId: "1234567890.0@msgr",
+  caption: "Here are some files",
+  attachments: [
+    { data: imageBuffer, fileName: "photo.jpg" },
+    { data: pdfBuffer, fileName: "document.pdf" }
+  ]
+});
+```
+
+**SendMultipleMediaInput**
+
+| Field | Type | Description |
+|---|---|---|
+| `threadId` | `string` | The target thread identifier. |
+| `attachments` | `SendAttachmentItem[]` | An array of attachment objects to send. |
+| `caption` | `string` | Optional caption. Applied to the bundled message for non-E2EE, or to the first attachment for E2EE. |
+| `replyToMessageId` | `string` | Optional message ID to reply to. |
+
+**SendAttachmentItem**
+
+| Field | Type | Description |
+|---|---|---|
+| `data` | `Buffer` | The raw file bytes. |
+| `fileName` | `string` | The filename. |
+| `mimeType` | `string` | Optional MIME type (inferred from filename extension if omitted). |
+| `width` | `number` | Optional width in pixels (for E2EE images/videos). |
+| `height` | `number` | Optional height in pixels (for E2EE images/videos). |
+| `seconds` | `number` | Optional duration in seconds (for E2EE videos/audios). |
+| `ptt` | `boolean` | Optional flag indicating if audio should be sent as voice note (push-to-talk). |
+
 ---
 
 ## Event Handling

package/dist/index.cjs

@@ -3472,6 +3472,30 @@ var FacebookGatewayService = class {
     );
     return response ?? {};
   }
+  /**
+   * Send multiple attachments in a single FCA message.
+   * FCA-unofficial accepts an array in `attachment` field, which bundles all
+   * files into one Messenger message on the wire.
+   */
+  async sendMultipleAttachmentsMessage(api, input) {
+    if (input.attachments.length === 0) {
+      throw new Error("sendMultipleAttachmentsMessage requires at least one attachment");
+    }
+    const streams = input.attachments.map(({ data, fileName }) => {
+      const stream = import_node_stream.Readable.from(data);
+      Object.assign(stream, { path: fileName });
+      return stream;
+    });
+    const payload = {
+      body: input.caption ?? "",
+      // FCA-unofficial accepts a single Readable or an array of Readables
+      attachment: streams.length === 1 ? streams[0] : streams
+    };
+    const response = await Promise.resolve(
+      api.sendMessage(payload, input.threadId, void 0, input.replyToMessageId)
+    );
+    return response ?? {};
+  }
   async sendReaction(api, messageId, reaction) {
     if (!api.setMessageReaction) {
       throw new Error("setMessageReaction is not available in fca-unofficial");
@@ -3648,6 +3672,13 @@ var MediaService = class {
       replyToMessageId: input.replyToMessageId
     });
   }
+  /**
+   * Send multiple attachments bundled into a single FCA message.
+   * Non-E2EE only — for E2EE threads use the controller which sends them sequentially.
+   */
+  async sendFiles(api, input) {
+    return this.gateway.sendMultipleAttachmentsMessage(api, input);
+  }
   async sendSticker(api, input) {
     return this.gateway.sendStickerMessage(api, {
       threadId: input.threadId,
@@ -3945,8 +3976,8 @@ init_cjs_shims();
 var MessageBuilder = class {
   content;
   replyTo;
-  setReply(id, senderJid) {
-    this.replyTo = { id, senderJid };
+  setReply(replyTo) {
+    this.replyTo = replyTo;
     return this;
   }
   getReply() {
@@ -4170,7 +4201,7 @@ function encodeMessageApplication(consumerAppBytes, replyTo) {
   const appPayload = new ProtoWriter().bytes(4, payloadSubProto).build();
   let metadataWriter = new ProtoWriter().bytes(8, frankingKey).varint(9, 0);
   if (replyTo) {
-    const quoted = new ProtoWriter().string(1, replyTo.id).string(2, replyTo.senderJid).build();
+    const quoted = new ProtoWriter().string(1, replyTo.messageId).string(2, replyTo.chatJid).string(3, replyTo.senderJid).build();
     metadataWriter = metadataWriter.bytes(10, quoted);
   }
   const metadata = metadataWriter.build();
@@ -5542,7 +5573,16 @@ var E2EEClient = class {
   async buildDMTextFanoutPayloads(opts) {
     const builder = new MessageBuilder().setText(opts.text);
     if (opts.replyToId && opts.replyToSenderJid) {
-      builder.setReply(opts.replyToId, opts.replyToSenderJid);
+      const replyTo = {
+        messageId: opts.replyToId,
+        // chatJid = remoteJID: the thread/chat that holds the quoted message
+        // For DM, this is the peer's bare JID (toJid).
+        chatJid: opts.toJid,
+        // senderJid = participant: who sent the original message.
+        // Caller must supply the correct sender JID via replyToSenderJid.
+        senderJid: opts.replyToSenderJid
+      };
+      builder.setReply(replyTo);
     }
     const consumerApp = builder.build();
     const { messageApp, frankingTag } = encodeMessageApplication(consumerApp, builder.getReply());
@@ -5577,7 +5617,14 @@ var E2EEClient = class {
   async encryptGroupText(groupJid, selfJid, text, messageId, replyToId, replyToSenderJid) {
     const builder = new MessageBuilder().setText(text);
     if (replyToId && replyToSenderJid) {
-      builder.setReply(replyToId, replyToSenderJid);
+      const replyTo = {
+        messageId: replyToId,
+        // chatJid = remoteJID: for a group message, this is the group JID
+        chatJid: groupJid,
+        // participant: the specific member who sent the original message
+        senderJid: replyToSenderJid
+      };
+      builder.setReply(replyTo);
     }
     const consumerApp = builder.build();
     const { messageApp, frankingTag } = encodeMessageApplication(consumerApp, builder.getReply());
@@ -8177,15 +8224,25 @@ var ClientController = class {
     if (this.e2eeConnected && isE2EE) {
       let messageId;
       if (isGroup) {
-        messageId = await this.sendE2EEGroupText(input.threadId, input.text, input.replyToMessageId);
+        messageId = await this.sendE2EEGroupText(
+          input.threadId,
+          input.text,
+          input.replyToMessageId,
+          input.replyToSenderJid
+        );
       } else {
-        messageId = await this.sendE2EEText(input.threadId, input.text, input.replyToMessageId);
+        messageId = await this.sendE2EEText(
+          input.threadId,
+          input.text,
+          input.replyToMessageId,
+          input.replyToSenderJid
+        );
       }
       return { messageId, timestampMs: now() };
     }
     return this.messagingService.sendText(this.requireApi(), input);
   }
-  async sendE2EEText(threadId, text, replyToMessageId) {
+  async sendE2EEText(threadId, text, replyToMessageId, replyToSenderJid) {
     if (!this.e2eeSocket) throw new Error("E2EE not connected");
     const e2eeClient = this.e2eeService.getClient();
     const selfJid = this.getSelfE2EEJid();
@@ -8197,7 +8254,9 @@ var ClientController = class {
       text,
       isGroup: false,
       replyToId: replyToMessageId,
-      replyToSenderJid: replyToMessageId ? toJid : void 0
+      // For DM: participant = sender of original msg. If caller knows who sent it, use that;
+      // otherwise fall back to the peer's JID (correct for messages they sent to us).
+      replyToSenderJid: replyToMessageId ? replyToSenderJid ?? toJid : void 0
     });
     const participantNodes = [];
     const deviceJids = uniqueJids(await this.e2eeHandler.getDeviceList([toJid, toBareMessengerJid(selfJid)]));
@@ -8243,7 +8302,7 @@ var ClientController = class {
     logger.info("ClientController", `E2EE DM message sent to ${toJid} with ${participantNodes.length} devices`);
     return messageId;
   }
-  async sendE2EEGroupText(groupJid, text, replyToMessageId) {
+  async sendE2EEGroupText(groupJid, text, replyToMessageId, replyToSenderJid) {
     if (!this.e2eeSocket) throw new Error("E2EE not connected");
     const e2eeClient = this.e2eeService.getClient();
     const selfJid = this.getSelfE2EEJid();
@@ -8259,7 +8318,8 @@ var ClientController = class {
       text,
       messageId,
       replyToMessageId,
-      void 0
+      replyToSenderJid
+      // pass through — undefined when not replying
     );
     const participantNodes = [];
     for (const deviceJid of deviceJids) {
@@ -8527,7 +8587,7 @@ var ClientController = class {
   async markAsRead(input) {
     await this.messagingService.markAsRead(this.requireApi(), input);
   }
-  // --- E2EE Media Upload Config ---
+  // E2EE Media Upload Config
   async getE2EEMediaUploadConfig() {
     if (this.e2eeUploadConfig && !this.isMediaUploadConfigExpired(this.e2eeUploadConfig)) {
       return this.e2eeUploadConfig;
@@ -8599,7 +8659,11 @@ var ClientController = class {
     const consumerApp = buildMessage(media.mediaFields);
     const { messageApp, frankingTag } = e2eeClient.buildMessageApplication(
       consumerApp,
-      input.replyToMessageId ? { id: input.replyToMessageId, senderJid: toJid } : void 0
+      input.replyToMessageId ? {
+        messageId: input.replyToMessageId,
+        chatJid: toJid,
+        senderJid: input.replyToSenderJid ?? toJid
+      } : void 0
     );
     const devicePayload = e2eeClient.buildMessageTransport({ messageApp });
     const selfDevicePayload = e2eeClient.buildMessageTransport({
@@ -8674,6 +8738,62 @@ var ClientController = class {
     }
     return this.mediaService.sendFile(this.requireApi(), input);
   }
+  /**
+   * Send multiple files/attachments.
+   *
+   * - **Non-E2EE threads**: All files are bundled into a single FCA message.
+   * - **E2EE threads**: Files are sent as separate sequential encrypted E2EE
+   *   media messages (the protocol does not support multi-attachment in one
+   *   encrypted frame). Returns an array with one result per attachment.
+   */
+  async sendFiles(input) {
+    if (input.attachments.length === 0) {
+      throw new Error("sendFiles requires at least one attachment");
+    }
+    if (this.e2eeConnected && this.isE2EEThreadId(input.threadId)) {
+      const results = [];
+      for (let i = 0; i < input.attachments.length; i++) {
+        const att = input.attachments[i];
+        const mediaInput = {
+          threadId: input.threadId,
+          data: att.data,
+          fileName: att.fileName,
+          mimeType: att.mimeType,
+          // Caption on first attachment only
+          caption: i === 0 ? input.caption : void 0,
+          replyToMessageId: i === 0 ? input.replyToMessageId : void 0,
+          width: att.width,
+          height: att.height,
+          seconds: att.seconds,
+          ptt: att.ptt
+        };
+        const mediaType = inferMediaType(att.fileName, att.mimeType);
+        let result;
+        switch (mediaType) {
+          case "image":
+            result = await this.sendE2EEImage(mediaInput);
+            break;
+          case "video":
+            result = await this.sendE2EEVideo(mediaInput);
+            break;
+          case "audio":
+            result = await this.sendE2EEAudio(mediaInput);
+            break;
+          default:
+            result = await this.sendE2EEFile(mediaInput);
+            break;
+        }
+        results.push(result);
+      }
+      return results;
+    }
+    return this.mediaService.sendFiles(this.requireApi(), {
+      threadId: input.threadId,
+      attachments: input.attachments.map((a) => ({ data: a.data, fileName: a.fileName })),
+      caption: input.caption,
+      replyToMessageId: input.replyToMessageId
+    });
+  }
   async sendSticker(input) {
     return this.mediaService.sendSticker(this.requireApi(), input);
   }
@@ -8713,7 +8833,6 @@ var ClientController = class {
   async createPoll(input) {
     await this.threadService.createPoll(this.requireApi(), input);
   }
-  // editMessage is now handled by the E2EE-aware method above (routes E2EE → sendE2EEEdit, else → threadService.editMessage).
   async addGroupMember(input) {
     await this.threadService.addGroupMember(this.requireApi(), input);
   }
@@ -8731,6 +8850,17 @@ var ClientController = class {
     return this.api;
   }
 };
+function inferMediaType(fileName, mimeType) {
+  const mime = (mimeType ?? "").toLowerCase();
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/")) return "audio";
+  const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+  if (["jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "bmp"].includes(ext)) return "image";
+  if (["mp4", "mov", "avi", "mkv", "webm", "3gp", "m4v"].includes(ext)) return "video";
+  if (["mp3", "ogg", "aac", "flac", "wav", "m4a", "opus"].includes(ext)) return "audio";
+  return "document";
+}
 
 // src/repositories/session.repository.ts
 init_cjs_shims();
@@ -8992,6 +9122,17 @@ var FBClient = class {
   async sendFile(input) {
     return this.controller.sendFile(input);
   }
+  /**
+   * Send multiple files/attachments in one call.
+   *
+   * - **Non-E2EE threads**: All attachments land in a single Messenger message.
+   * - **E2EE threads**: Each attachment is sent as a separate encrypted message
+   *   (E2EE does not support multi-attachment in one frame). Returns an array
+   *   with one result per attachment.
+   */
+  async sendFiles(input) {
+    return this.controller.sendFiles(input);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {