fb-messenger-e2ee 0.1.2 → 0.1.3

package/DOCS.md

@@ -144,14 +144,52 @@ await client.sendReaction({
 });
 ```
 
-### `unsendMessage(messageId: string, threadId?: string)`
+### `unsendMessage(input: UnsendMessageInput)`
 
-Un-sends/revokes an E2EE message you previously sent. Pass `threadId` unless the original send result is still in the short outbound cache.
+Un-sends/revokes an E2EE message you previously sent. 
+You must provide the exact `messageId`. 
+Providing the `threadId` is highly recommended to ensure the E2EE client knows the destination JID.
 
 ```typescript
-await client.unsendMessage(sent.messageId, "1234567890.0@msgr");
+await client.unsendMessage({ 
+  messageId: sent.messageId, 
+  threadId: "1234567890.0@msgr" 
+});
 ```
 
+**UnsendMessageInput**
+
+| Field | Type | Description |
+|---|---|---|
+| `messageId` | `string` | The message ID to revoke. |
+| `threadId` | `string` | Optional but highly recommended target thread identifier. |
+| `fromMe` | `boolean` | Optional flag indicating if the message was sent by you (defaults to `true`). |
+
+### `editMessage(input: E2EEEditMessageInput)`
+
+Edits the text of an E2EE message you previously sent.
+You must provide the exact `messageId` (the 15-digit numeric ID returned by `sendMessage`) and the `threadId`.
+
+```typescript
+const sent = await client.sendMessage({ threadId: "1234567890.0@msgr", text: "oops" });
+const messageId = sent.messageId as string;
+
+// ... a few seconds later
+await client.editMessage({
+  threadId: "1234567890.0@msgr",
+  messageId,
+  newText: "corrected message",
+});
+```
+
+**E2EEEditMessageInput**
+
+| Field | Type | Description |
+|---|---|---|
+| `threadId` | `string` | The thread ID (E2EE chat JID) containing the message. |
+| `messageId` | `string` | The message ID to edit. |
+| `newText` | `string` | The replacement text content. |
+
 ### `sendTyping(input: TypingInput)`
 
 Sends E2EE chatstate (`composing` / `paused`) over the Noise socket.

package/dist/index.cjs

@@ -8175,12 +8175,13 @@ var ClientController = class {
     const isE2EE = this.isE2EEThreadId(input.threadId);
     const isGroup = input.threadId.includes("@g.us") || input.threadId.includes(".g.");
     if (this.e2eeConnected && isE2EE) {
+      let messageId;
       if (isGroup) {
-        await this.sendE2EEGroupText(input.threadId, input.text, input.replyToMessageId);
+        messageId = await this.sendE2EEGroupText(input.threadId, input.text, input.replyToMessageId);
       } else {
-        await this.sendE2EEText(input.threadId, input.text, input.replyToMessageId);
+        messageId = await this.sendE2EEText(input.threadId, input.text, input.replyToMessageId);
       }
-      return { messageId: `e2ee-${now()}`, timestampMs: now() };
+      return { messageId, timestampMs: now() };
     }
     return this.messagingService.sendText(this.requireApi(), input);
   }
@@ -8240,6 +8241,7 @@ var ClientController = class {
       createdAtMs: now()
     });
     logger.info("ClientController", `E2EE DM message sent to ${toJid} with ${participantNodes.length} devices`);
+    return messageId;
   }
   async sendE2EEGroupText(groupJid, text, replyToMessageId) {
     if (!this.e2eeSocket) throw new Error("E2EE not connected");
@@ -8302,6 +8304,7 @@ var ClientController = class {
       createdAtMs: now()
     });
     logger.info("ClientController", `E2EE Group message sent to ${groupJid} with ${participantNodes.length} devices`);
+    return messageId;
   }
   getSelfE2EEJid() {
     const device = this.activeDeviceStore?.jidDevice ?? 0;
@@ -8313,8 +8316,210 @@ var ClientController = class {
   async sendReaction(input) {
     await this.messagingService.react(this.requireApi(), input);
   }
-  async unsendMessage(messageId) {
-    await this.messagingService.unsend(this.requireApi(), messageId);
+  /**
+   * Unsend/revoke a message.
+   *
+   * - **E2EE threads**: Sends an encrypted `ConsumerApplication { applicationData { revoke } }`
+   *   message over the Noise socket. The `fromMe` flag in the revoke key determines
+   *   whether it is a sender revoke (`true`, default) or an admin revoke (`false`).
+   * - **Non-E2EE threads**: Falls back to `fca-unofficial` HTTP unsend.
+   */
+  async unsendMessage(input) {
+    const isE2EE = this.isE2EEThreadId(input.threadId);
+    if (this.e2eeConnected && isE2EE) {
+      await this.sendE2EERevoke(input.threadId, input.messageId, input.fromMe ?? true);
+      return;
+    }
+    await this.messagingService.unsend(this.requireApi(), input.messageId);
+  }
+  /**
+   * Send an E2EE revoke (unsend) for a DM or group message.
+   *
+   * Builds a `ConsumerApplication { applicationData { revoke { key { id, fromMe } } } }`
+   * payload, wraps it in MessageApplication + MessageTransport, then fans out to all
+   * participant devices exactly like a normal DM or group text — but with the
+   * correct edit attribute on the `<message>` node so the server and
+   * receiving clients apply the correct revoke semantics.
+   */
+  async sendE2EERevoke(threadId, messageId, fromMe) {
+    if (!this.e2eeSocket) throw new Error("E2EE not connected");
+    const e2eeClient = this.e2eeService.getClient();
+    const selfJid = this.getSelfE2EEJid();
+    const isGroup = threadId.includes("@g.us") || threadId.includes(".g.");
+    const editAttr = fromMe ? "7" : "8";
+    const toJid = isGroup ? threadId : normalizeDMThreadToJid(threadId);
+    const consumerApp = e2eeClient.buildRevokeMessage(messageId, { fromMe, remoteJid: toJid });
+    const { messageApp, frankingTag } = e2eeClient.buildMessageApplication(consumerApp);
+    const newMessageId = String(BigInt(Math.floor(Math.random() * 1e15)));
+    if (isGroup) {
+      const memberJids = await this.e2eeHandler.getGroupParticipants(threadId);
+      const deviceUsers = uniqueJids([...memberJids, toBareMessengerJid(selfJid)]);
+      const deviceJids = uniqueJids(await this.e2eeHandler.getDeviceList(deviceUsers)).filter((jid) => !sameMessengerDevice(jid, selfJid));
+      const groupResult = await e2eeClient.encryptGroupMessageApplication(
+        threadId,
+        selfJid,
+        messageApp,
+        newMessageId
+      );
+      const participantNodes = [];
+      for (const deviceJid of deviceJids) {
+        try {
+          if (!await e2eeClient.hasSession(deviceJid)) {
+            const bundle = await this.e2eeHandler.getPreKeyBundle(deviceJid);
+            await e2eeClient.establishSession(deviceJid, bundle);
+          }
+          const payload = sameMessengerUser(deviceJid, selfJid) ? groupResult.selfDevicePayload : groupResult.devicePayload;
+          const skdmEnc = await e2eeClient.encryptDevicePayload(deviceJid, selfJid, payload);
+          participantNodes.push(encodeNode("to", { jid: deviceJid }, [
+            encodeNode("enc", { v: "3", type: skdmEnc.type }, skdmEnc.ciphertext)
+          ]));
+        } catch (err) {
+          logger.error("ClientController", `Failed to distribute revoke SKDM to ${deviceJid}:`, err);
+        }
+      }
+      const phash = buildParticipantListHash(deviceJids);
+      const msgNode = encodeNode("message", { to: threadId, type: "text", id: newMessageId, phash, edit: editAttr }, [
+        encodeNode("participants", {}, participantNodes),
+        encodeNode("franking", {}, [encodeNode("franking_tag", {}, frankingTag)]),
+        encodeNode("trace", {}, [encodeNode("request_id", {}, Buffer.from((0, import_node_crypto11.randomUUID)().replace(/-/g, ""), "hex"))]),
+        encodeNode("enc", { v: "3", type: "skmsg", "decrypt-fail": "hide" }, groupResult.groupCiphertext)
+      ]);
+      await this.e2eeSocket.sendFrame(marshal(msgNode));
+      logger.info("ClientController", `E2EE group revoke sent for message ${messageId} in ${threadId}`);
+    } else {
+      const devicePayload = e2eeClient.buildMessageTransport({ messageApp });
+      const selfDevicePayload = e2eeClient.buildMessageTransport({
+        messageApp,
+        dsm: { destinationJid: toJid, phash: "" }
+      });
+      const participantNodes = [];
+      const deviceJids = uniqueJids(await this.e2eeHandler.getDeviceList([toJid, toBareMessengerJid(selfJid)]));
+      for (const deviceJid of deviceJids) {
+        if (sameMessengerDevice(deviceJid, selfJid)) continue;
+        try {
+          if (!await e2eeClient.hasSession(deviceJid)) {
+            const bundle = await this.e2eeHandler.getPreKeyBundle(deviceJid);
+            await e2eeClient.establishSession(deviceJid, bundle);
+          }
+          const payload = sameMessengerUser(deviceJid, selfJid) ? selfDevicePayload : devicePayload;
+          const encrypted = await e2eeClient.encryptDevicePayload(deviceJid, selfJid, payload);
+          participantNodes.push(encodeNode("to", { jid: deviceJid }, [
+            encodeNode("enc", { v: "3", type: encrypted.type, "decrypt-fail": "hide" }, encrypted.ciphertext)
+          ]));
+        } catch (err) {
+          logger.error("ClientController", `Failed to encrypt revoke to ${deviceJid}:`, err);
+        }
+      }
+      const msgNode = encodeNode("message", { to: toJid, type: "text", id: newMessageId, edit: editAttr }, [
+        encodeNode("participants", {}, participantNodes),
+        encodeNode("franking", {}, [encodeNode("franking_tag", {}, frankingTag)]),
+        encodeNode("trace", {}, [encodeNode("request_id", {}, Buffer.from((0, import_node_crypto11.randomUUID)().replace(/-/g, ""), "hex"))])
+      ]);
+      await this.e2eeSocket.sendFrame(marshal(msgNode));
+      logger.info("ClientController", `E2EE DM revoke sent for message ${messageId} to ${toJid}`);
+    }
+  }
+  /**
+   * Edit an E2EE message (change its text).
+   *
+   * - **E2EE threads**: Sends an encrypted `ConsumerApplication { content { editMessage { key, message, timestampMS } } }`
+   *   payload with the edit message attribute set.
+   * - **Non-E2EE threads**: Falls back to `fca-unofficial` HTTP edit.
+   */
+  async editMessage(input) {
+    const isE2EE = this.isE2EEThreadId(input.threadId);
+    if (this.e2eeConnected && isE2EE) {
+      await this.sendE2EEEdit(input.threadId, input.messageId, input.newText);
+      return;
+    }
+    await this.threadService.editMessage(this.requireApi(), {
+      messageId: input.messageId,
+      newText: input.newText
+    });
+  }
+  /**
+   * Send an E2EE message edit for a DM or group message.
+   *
+   * Builds a `ConsumerApplication { payload { content { editMessage { key, message, timestampMS } } } }`
+   * payload, fanned out to all participant devices exactly like a normal message send.
+   */
+  async sendE2EEEdit(threadId, messageId, newText) {
+    if (!this.e2eeSocket) throw new Error("E2EE not connected");
+    const e2eeClient = this.e2eeService.getClient();
+    const selfJid = this.getSelfE2EEJid();
+    const isGroup = threadId.includes("@g.us") || threadId.includes(".g.");
+    const editAttr = "1";
+    const toJid = isGroup ? threadId : normalizeDMThreadToJid(threadId);
+    const consumerApp = e2eeClient.buildEditMessage(messageId, newText);
+    const { messageApp, frankingTag } = e2eeClient.buildMessageApplication(consumerApp);
+    const newMessageId = String(BigInt(Math.floor(Math.random() * 1e15)));
+    if (isGroup) {
+      const memberJids = await this.e2eeHandler.getGroupParticipants(threadId);
+      const deviceUsers = uniqueJids([...memberJids, toBareMessengerJid(selfJid)]);
+      const deviceJids = uniqueJids(await this.e2eeHandler.getDeviceList(deviceUsers)).filter((jid) => !sameMessengerDevice(jid, selfJid));
+      const groupResult = await e2eeClient.encryptGroupMessageApplication(
+        threadId,
+        selfJid,
+        messageApp,
+        newMessageId
+      );
+      const participantNodes = [];
+      for (const deviceJid of deviceJids) {
+        try {
+          if (!await e2eeClient.hasSession(deviceJid)) {
+            const bundle = await this.e2eeHandler.getPreKeyBundle(deviceJid);
+            await e2eeClient.establishSession(deviceJid, bundle);
+          }
+          const payload = sameMessengerUser(deviceJid, selfJid) ? groupResult.selfDevicePayload : groupResult.devicePayload;
+          const skdmEnc = await e2eeClient.encryptDevicePayload(deviceJid, selfJid, payload);
+          participantNodes.push(encodeNode("to", { jid: deviceJid }, [
+            encodeNode("enc", { v: "3", type: skdmEnc.type }, skdmEnc.ciphertext)
+          ]));
+        } catch (err) {
+          logger.error("ClientController", `Failed to distribute edit SKDM to ${deviceJid}:`, err);
+        }
+      }
+      const phash = buildParticipantListHash(deviceJids);
+      const msgNode = encodeNode("message", { to: threadId, type: "text", id: newMessageId, phash, edit: editAttr }, [
+        encodeNode("participants", {}, participantNodes),
+        encodeNode("franking", {}, [encodeNode("franking_tag", {}, frankingTag)]),
+        encodeNode("trace", {}, [encodeNode("request_id", {}, Buffer.from((0, import_node_crypto11.randomUUID)().replace(/-/g, ""), "hex"))]),
+        encodeNode("enc", { v: "3", type: "skmsg", "decrypt-fail": "hide" }, groupResult.groupCiphertext)
+      ]);
+      await this.e2eeSocket.sendFrame(marshal(msgNode));
+      logger.info("ClientController", `E2EE group edit sent for message ${messageId} in ${threadId}`);
+    } else {
+      const devicePayload = e2eeClient.buildMessageTransport({ messageApp });
+      const selfDevicePayload = e2eeClient.buildMessageTransport({
+        messageApp,
+        dsm: { destinationJid: toJid, phash: "" }
+      });
+      const participantNodes = [];
+      const deviceJids = uniqueJids(await this.e2eeHandler.getDeviceList([toJid, toBareMessengerJid(selfJid)]));
+      for (const deviceJid of deviceJids) {
+        if (sameMessengerDevice(deviceJid, selfJid)) continue;
+        try {
+          if (!await e2eeClient.hasSession(deviceJid)) {
+            const bundle = await this.e2eeHandler.getPreKeyBundle(deviceJid);
+            await e2eeClient.establishSession(deviceJid, bundle);
+          }
+          const payload = sameMessengerUser(deviceJid, selfJid) ? selfDevicePayload : devicePayload;
+          const encrypted = await e2eeClient.encryptDevicePayload(deviceJid, selfJid, payload);
+          participantNodes.push(encodeNode("to", { jid: deviceJid }, [
+            encodeNode("enc", { v: "3", type: encrypted.type, "decrypt-fail": "hide" }, encrypted.ciphertext)
+          ]));
+        } catch (err) {
+          logger.error("ClientController", `Failed to encrypt edit to ${deviceJid}:`, err);
+        }
+      }
+      const msgNode = encodeNode("message", { to: toJid, type: "text", id: newMessageId, edit: editAttr }, [
+        encodeNode("participants", {}, participantNodes),
+        encodeNode("franking", {}, [encodeNode("franking_tag", {}, frankingTag)]),
+        encodeNode("trace", {}, [encodeNode("request_id", {}, Buffer.from((0, import_node_crypto11.randomUUID)().replace(/-/g, ""), "hex"))])
+      ]);
+      await this.e2eeSocket.sendFrame(marshal(msgNode));
+      logger.info("ClientController", `E2EE DM edit sent for message ${messageId} to ${toJid}`);
+    }
   }
   async sendTyping(input) {
     await this.messagingService.sendTyping(this.requireApi(), input);
@@ -8508,9 +8713,7 @@ var ClientController = class {
   async createPoll(input) {
     await this.threadService.createPoll(this.requireApi(), input);
   }
-  async editMessage(input) {
-    return this.threadService.editMessage(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);
   }
@@ -8767,8 +8970,11 @@ var FBClient = class {
   async sendReaction(input) {
     await this.controller.sendReaction(input);
   }
-  async unsendMessage(messageId) {
-    await this.controller.unsendMessage(messageId);
+  async unsendMessage(input) {
+    await this.controller.unsendMessage(input);
+  }
+  async editMessage(input) {
+    await this.controller.editMessage(input);
   }
   async sendTyping(input) {
     await this.controller.sendTyping(input);