fb-messenger-e2ee 0.1.1 → 0.1.2

package/tests/types.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { type AssertEqual, TypedEventEmitter } from "../src/types/advanced-types.ts";
-import type { Attachment, ImageAttachment, VideoAttachment } from "../src/models/domain.ts";
-import type { MessengerEventMap } from "../src/models/client.ts";
-
-describe("Type-level Tests", () => {
-  it("AssertEqual utility works", () => {
-    type Test1 = AssertEqual<string, string>;
-    const val1: Test1 = true;
-    expect(val1).toBe(true);
-
-    type Test2 = AssertEqual<string, number>;
-    const val2: Test2 = false;
-    expect(val2).toBe(false);
-  });
-
-  it("Attachment is a Discriminated Union", () => {
-    // This test is mostly for compile-time validation
-    const check = (att: Attachment) => {
-      if (att.type === "image") {
-        type IsImage = AssertEqual<typeof att, ImageAttachment>;
-        // If this compiles, it means type narrowing works
-      } else if (att.type === "video") {
-        type IsVideo = AssertEqual<typeof att, VideoAttachment>;
-      }
-    };
-    expect(check).toBeDefined();
-  });
-
-  it("TypedEventEmitter enforces payload types", () => {
-    type Events = {
-      ping: { count: number };
-      pong: { message: string };
-    };
-    const emitter = new TypedEventEmitter<Events>();
-
-    let receivedCount = 0;
-    emitter.on("ping", (data) => {
-      receivedCount = data.count;
-    });
-
-    emitter.emit("ping", { count: 42 });
-    expect(receivedCount).toBe(42);
-
-    // emitter.emit("ping", { message: "error" }); // Should cause compile error
-  });
-
-  it("MessengerEventMap is correctly derived", () => {
-    type HasMessage = "message" extends keyof MessengerEventMap ? true : false;
-    const hasMessage: HasMessage = true;
-    expect(hasMessage).toBe(true);
-
-    type MessagePayload = MessengerEventMap["message"];
-    // Should be MessengerMessage
-    expect(true).toBe(true);
-  });
-});

package/tests/unit/controllers/dgw-handler.test.ts

@@ -1,60 +0,0 @@
-import { jest, describe, it, expect, beforeEach } from "@jest/globals";
-import { DGWHandler } from "../../../src/controllers/dgw-handler.ts";
-import { EventMapper } from "../../../src/controllers/event-mapper.ts";
-
-describe("DGWHandler", () => {
-  let eventMapper: EventMapper;
-  let handler: DGWHandler;
-
-  beforeEach(() => {
-    eventMapper = {
-      emitMappedEvent: jest.fn(),
-      emit: jest.fn()
-    } as any;
-    handler = new DGWHandler(eventMapper);
-  });
-
-  it("should handle a valid DGW frame with insertMessage", () => {
-    const frame = {
-      payloadJson: JSON.stringify({
-        payload: JSON.stringify([
-          5, "insertMessage", 
-          "hello from dgw", // 0: text
-          null, null,
-          "123456", // 3: chatJid
-          null,
-          1600000000000, // 5: timestamp
-          null, null,
-          "mid.dgw.1", // 8: messageId
-          null,
-          "1001" // 10: senderJid
-        ])
-      })
-    };
-
-    handler.handleDGWFrame(frame as any);
-
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledWith(expect.objectContaining({
-      type: "e2ee_message",
-      data: expect.objectContaining({
-        messageId: "mid.dgw.1",
-        text: "hello from dgw"
-      })
-    }));
-  });
-
-  it("should ignore duplicate message IDs", () => {
-    const frame = {
-      payloadJson: JSON.stringify({
-        payload: JSON.stringify([
-          5, "insertMessage", "hello", null, null, "123", null, 123, null, null, "mid.dup", null, "100"
-        ])
-      })
-    };
-
-    handler.handleDGWFrame(frame as any);
-    handler.handleDGWFrame(frame as any);
-
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/unit/controllers/e2ee-handler.test.ts

@@ -1,293 +0,0 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
-import { E2EEHandler } from "../../../src/controllers/e2ee-handler.ts";
-import { EventMapper } from "../../../src/controllers/event-mapper.ts";
-import { DeviceStore } from "../../../src/e2ee/store/device-store.ts";
-import { unmarshal, type Node } from "../../../src/e2ee/transport/binary/wa-binary.ts";
-import {
-  encodeImageMessage,
-  encodeMessageApplication,
-  encodeMessageTransport,
-  encodeRevokeMessage,
-  encodeTextMessage,
-} from "../../../src/e2ee/message/message-builder.ts";
-
-const buildTransport = (consumerApplication: Buffer) => {
-  const { messageApp } = encodeMessageApplication(consumerApplication);
-  return encodeMessageTransport({ messageApp, padding: Buffer.from([1]) });
-};
-
-describe("E2EEHandler", () => {
-  let eventMapper: EventMapper;
-  let socket: any;
-  let store: any;
-  let handler: E2EEHandler;
-  let logSpy: jest.SpiedFunction<typeof console.log>;
-  let warnSpy: jest.SpiedFunction<typeof console.warn>;
-
-  beforeEach(() => {
-    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
-    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-    eventMapper = {
-      emitMappedEvent: jest.fn(),
-      emit: jest.fn()
-    } as any;
-    socket = {
-      sendFrame: jest.fn<() => Promise<void>>().mockResolvedValue(undefined as any)
-    };
-    store = { jidDevice: 1, registrationId: 1234 };
-    handler = new E2EEHandler(
-      eventMapper,
-      () => socket,
-      () => store
-    );
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-    warnSpy.mockRestore();
-  });
-
-  it("should handle IQ ping", () => {
-    const node = {
-      tag: "iq",
-      attrs: { id: "123", xmlns: "urn:xmpp:ping", type: "get", from: "s.whatsapp.net" },
-      content: undefined
-    };
-
-    handler.handleIQ(node as any);
-
-    expect(socket.sendFrame).toHaveBeenCalled();
-    const mock = (socket.sendFrame as any);
-    expect(mock.mock.calls[0][0]).toBeDefined();
-  });
-
-  it("should decrypt and emit normalized DM text messages", async () => {
-    const plaintext = buildTransport(encodeTextMessage("hello"));
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.1", from: "1001.2@msgr", type: "chat" },
-      content: [
-        { tag: "enc", attrs: { v: "3", type: "msg" }, content: Buffer.from("ciphertext") }
-      ]
-    };
-    const e2eeClient = {
-      decryptDMMessage: jest.fn<(senderJid: string, ciphertext: Buffer) => Promise<Buffer>>().mockResolvedValue(plaintext as any)
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self_id", e2eeClient as any);
-
-    expect(e2eeClient.decryptDMMessage).toHaveBeenCalledWith("1001.2@msgr", Buffer.from("ciphertext"));
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledWith({
-      type: "e2ee_message",
-      data: expect.objectContaining({
-        kind: "text",
-        text: "hello",
-        messageId: "mid.1",
-        senderJid: "1001.2@msgr",
-        senderId: "1001",
-      }),
-    });
-  });
-
-  it("should normalize application-data revoke messages", async () => {
-    const plaintext = buildTransport(encodeRevokeMessage("mid.remove", true));
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.revoke", from: "1001.2@msgr", type: "chat" },
-      content: [
-        { tag: "enc", attrs: { v: "3", type: "msg" }, content: Buffer.from("ciphertext") }
-      ]
-    };
-    const e2eeClient = {
-      decryptDMMessage: jest.fn<(senderJid: string, ciphertext: Buffer) => Promise<Buffer>>().mockResolvedValue(plaintext as any)
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self_id", e2eeClient as any);
-
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledWith({
-      type: "e2ee_message",
-      data: expect.objectContaining({
-        kind: "revoke",
-        targetId: "mid.remove",
-        fromMe: true,
-      }),
-    });
-  });
-
-  it("should emit media messages after decoding the ConsumerApplication wrapper", async () => {
-    const plaintext = buildTransport(encodeImageMessage({
-      mimeType: "image/png",
-      fileSHA256: Buffer.alloc(32, 1),
-      fileLength: 10,
-      mediaKey: Buffer.alloc(32, 2),
-      fileEncSHA256: Buffer.alloc(32, 3),
-      directPath: "/mms/image",
-      caption: "photo caption",
-    }));
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.image", from: "1001.2@msgr", type: "chat" },
-      content: [
-        { tag: "enc", attrs: { v: "3", type: "msg" }, content: Buffer.from("ciphertext") }
-      ]
-    };
-    const e2eeClient = {
-      decryptDMMessage: jest.fn<(senderJid: string, ciphertext: Buffer) => Promise<Buffer>>().mockResolvedValue(plaintext as any)
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self_id", e2eeClient as any);
-
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledWith({
-      type: "e2ee_message",
-      data: expect.objectContaining({
-        kind: "image",
-        media: expect.objectContaining({
-          caption: expect.objectContaining({ text: "photo caption" }),
-          image: expect.objectContaining({ version: 1 }),
-        }),
-      }),
-    });
-  });
-
-  it("processes participant SKDM fanout before acknowledging a group message without main enc", async () => {
-    const skdmBytes = Buffer.from("skdm-bytes");
-    const participantTransport = encodeMessageTransport({
-      padding: Buffer.from([1]),
-      skdm: { groupId: "180@g.us", skdmBytes },
-    });
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.skdm", from: "180@g.us", participant: "1001.2@msgr" },
-      content: [
-        {
-          tag: "participants",
-          attrs: {},
-          content: [
-            {
-              tag: "to",
-              attrs: { jid: "self:1@msgr" },
-              content: [{ tag: "enc", attrs: { type: "msg" }, content: Buffer.from("participant-ciphertext") }],
-            },
-          ],
-        },
-      ],
-    };
-    const e2eeClient = {
-      decryptDMMessage: jest.fn<(senderJid: string, ciphertext: Buffer) => Promise<Buffer>>().mockResolvedValue(participantTransport as any),
-      processSenderKeyDistribution: jest.fn<(senderJid: string, skdm: Buffer, groupJid?: string) => Promise<void>>().mockResolvedValue(undefined),
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self", e2eeClient as any);
-
-    expect(e2eeClient.decryptDMMessage).toHaveBeenCalledWith("1001.2@msgr", Buffer.from("participant-ciphertext"));
-    expect(e2eeClient.processSenderKeyDistribution).toHaveBeenCalledWith("1001.2@msgr", skdmBytes, "180@g.us");
-    expect(unmarshal(socket.sendFrame.mock.calls.at(-1)![0] as Buffer)).toMatchObject({
-      tag: "ack",
-      attrs: { class: "message", id: "mid.skdm", to: "180@g.us", participant: "1001.2@msgr" },
-    });
-  });
-
-  it("sends retry receipts for unavailable encrypted group messages", async () => {
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.unavailable", from: "180@g.us", participant: "1001.2@msgr", t: "123" },
-      content: [{ tag: "unavailable", attrs: { type: "skmsg" } }],
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self", {} as any);
-
-    const receipt = unmarshal(socket.sendFrame.mock.calls[0][0] as Buffer);
-    const ack = unmarshal(socket.sendFrame.mock.calls.at(-1)![0] as Buffer);
-    expect(receipt).toMatchObject({
-      tag: "receipt",
-      attrs: { id: "mid.unavailable", to: "180@g.us", type: "retry", participant: "1001.2@msgr" },
-    });
-    const receiptChildren = receipt.content as Node[];
-    expect(receiptChildren.find(n => n.tag === "retry")).toMatchObject({
-      attrs: { count: "1", id: "mid.unavailable", t: "123", v: "1" },
-    });
-    expect(receiptChildren.find(n => n.tag === "registration")!.content).toEqual(Buffer.from([0, 0, 4, 210]));
-    expect(ack).toMatchObject({
-      tag: "ack",
-      attrs: { class: "message", id: "mid.unavailable", to: "180@g.us", participant: "1001.2@msgr" },
-    });
-    expect(eventMapper.emitMappedEvent).toHaveBeenCalledWith({
-      type: "e2ee_message",
-      data: expect.objectContaining({
-        type: "decryption_failed",
-        error: "unavailable encrypted message: skmsg",
-        messageId: "mid.unavailable",
-      }),
-    });
-  });
-
-  it("caps retry receipts per message", async () => {
-    const node = {
-      tag: "message",
-      attrs: { id: "mid.retry-cap", from: "180@g.us", participant: "1001.2@msgr" },
-      content: [{ tag: "unavailable", attrs: { type: "skmsg" } }],
-    };
-
-    await handler.handleEncryptedMessage(node as any, "self", {} as any);
-    await handler.handleEncryptedMessage(node as any, "self", {} as any);
-    await handler.handleEncryptedMessage(node as any, "self", {} as any);
-
-    const sentNodes = socket.sendFrame.mock.calls.map((call: any[]) => unmarshal(call[0]));
-    expect(sentNodes.filter((n: Node) => n.tag === "receipt")).toHaveLength(2);
-    expect(sentNodes.filter((n: Node) => n.tag === "ack")).toHaveLength(3);
-  });
-
-  it("uploads fresh prekeys when encrypt notification reports a low count", async () => {
-    store = await DeviceStore.memoryOnly();
-    handler = new E2EEHandler(eventMapper, () => socket, () => store);
-
-    await handler.handleNotification({
-      tag: "notification",
-      attrs: { type: "encrypt", from: "s.whatsapp.net" },
-      content: [{ tag: "count", attrs: { value: "3" } }],
-    } as any);
-
-    const iq = unmarshal(socket.sendFrame.mock.calls[0][0] as Buffer);
-    const children = iq.content as Node[];
-    const list = children.find(n => n.tag === "list")!;
-    expect(iq).toMatchObject({ tag: "iq", attrs: { to: "s.whatsapp.net", type: "set", xmlns: "encrypt" } });
-    expect(children.find(n => n.tag === "registration")!.content).toHaveLength(4);
-    expect(children.find(n => n.tag === "identity")!.content).toHaveLength(32);
-    expect((list.content as Node[])).toHaveLength(50);
-    expect(children.find(n => n.tag === "skey")).toBeDefined();
-  });
-
-
-  it("fetches media upload config from media_conn IQ result", async () => {
-    let sentIq: Node | null = null;
-    socket.sendFrame = jest.fn<(frame: Buffer) => Promise<void>>().mockImplementation(async (frame: Buffer) => {
-      sentIq = unmarshal(frame);
-      const id = sentIq.attrs.id;
-      handler.handleIQ({
-        tag: "iq",
-        attrs: { id, type: "result", from: "s.whatsapp.net" },
-        content: [{
-          tag: "media_conn",
-          attrs: { auth: "real-auth", ttl: "3600", auth_ttl: "7200", max_buckets: "20" },
-          content: [
-            { tag: "host", attrs: { hostname: "primary.example" } },
-            { tag: "host", attrs: { hostname: "rupload.facebook.com" } },
-          ],
-        }],
-      } as any);
-    });
-
-    await expect(handler.getMediaUploadConfig()).resolves.toMatchObject({
-      host: "rupload.facebook.com",
-      auth: "real-auth",
-      ttl: 3600,
-      authTtl: 7200,
-    });
-    expect(sentIq).toMatchObject({
-      tag: "iq",
-      attrs: { to: "s.whatsapp.net", type: "set", xmlns: "w:m" },
-    });
-    expect((sentIq!.content as Node[])[0]).toMatchObject({ tag: "media_conn", attrs: {} });
-  });
-
-});

package/tests/unit/controllers/event-mapper.test.ts

@@ -1,252 +0,0 @@
-import { jest, describe, it, expect, beforeEach } from "@jest/globals";
-import { EventEmitter } from "node:events";
-import { EventMapper } from "../../../src/controllers/event-mapper.ts";
-import { MediaService } from "../../../src/services/media.service.ts";
-import { E2EEService } from "../../../src/services/e2ee.service.ts";
-
-describe("EventMapper", () => {
-  let eventBus: EventEmitter;
-  let mediaService: MediaService;
-  let e2eeService: E2EEService;
-  let mapper: EventMapper;
-
-  beforeEach(() => {
-    eventBus = new EventEmitter();
-    // Mock services
-    mediaService = {
-      normalizeAttachment: jest.fn().mockImplementation(item => item)
-    } as any;
-    e2eeService = {
-      markConnected: jest.fn()
-    } as any;
-    mapper = new EventMapper(eventBus, mediaService, e2eeService);
-  });
-
-  it("should map a simple text message", (done) => {
-    const raw = {
-      type: "message",
-      messageID: "mid.123",
-      threadID: "1000",
-      senderID: "1001",
-      body: "hello world",
-      timestamp: 1600000000000,
-      attachments: []
-    };
-
-    eventBus.on("message", (data) => {
-      expect(data.id).toBe("mid.123");
-      expect(data.text).toBe("hello world");
-      expect(data.senderId).toBe("1001");
-      done();
-    });
-
-    mapper.emitMappedEvent(raw);
-  });
-
-  it("should map a message reply", (done) => {
-    const raw = {
-      type: "message_reply",
-      messageID: "mid.reply",
-      threadID: "1000",
-      senderID: "1001",
-      body: "replying",
-      messageReply: {
-        messageID: "mid.original",
-        senderID: "1002",
-        body: "original content"
-      }
-    };
-
-    eventBus.on("message", (data) => {
-      expect(data.replyTo).toBeDefined();
-      expect(data.replyTo.messageId).toBe("mid.original");
-      done();
-    });
-
-    mapper.emitMappedEvent(raw);
-  });
-
-  it("should map a message edit", (done) => {
-    const raw = {
-      type: "message_edit",
-      messageID: "mid.123",
-      threadID: "1000",
-      newText: "edited text",
-      editCount: 1
-    };
-
-    eventBus.on("messageEdit", (data) => {
-      expect(data.newText).toBe("edited text");
-      done();
-    });
-
-    mapper.emitMappedEvent(raw);
-  });
-
-  it("should map a reaction", (done) => {
-    const raw = {
-      type: "reaction",
-      messageID: "mid.123",
-      threadID: "1000",
-      senderID: "1001",
-      reaction: "👍"
-    };
-
-    eventBus.on("reaction", (data) => {
-      expect(data.reaction).toBe("👍");
-      expect(data.actorId).toBe("1001");
-      done();
-    });
-
-    mapper.emitMappedEvent(raw);
-  });
-
-  it("should map typing status", (done) => {
-    const raw = {
-      type: "typ",
-      threadID: "1000",
-      from: "1001",
-      isTyping: true
-    };
-
-    eventBus.on("typing", (data) => {
-      expect(data.isTyping).toBe(true);
-      expect(data.senderId).toBe("1001");
-      done();
-    });
-
-    mapper.emitMappedEvent(raw);
-  });
-
-  it("should normalize E2EE message identity and omit empty optional fields", (done) => {
-    eventBus.on("e2ee_message", (data) => {
-      expect(data.id).toBe("7456191609143713633");
-      expect(data.threadId).toBe("100042415119261");
-      expect(data.chatJid).toBe("100042415119261.0@msgr");
-      expect(data.senderJid).toBe("100042415119261.160@msgr");
-      expect(data.senderId).toBe("100042415119261");
-      expect(data.senderDeviceId).toBe(160);
-      expect(data.isGroup).toBe(false);
-      expect(data.kind).toBe("text");
-      expect(data.text).toBe("Hehe");
-      expect(Object.prototype.hasOwnProperty.call(data, "attachments")).toBe(false);
-      expect(Object.prototype.hasOwnProperty.call(data, "mentions")).toBe(false);
-      expect(Object.prototype.hasOwnProperty.call(data, "replyTo")).toBe(false);
-      done();
-    });
-
-    mapper.emitMappedEvent({
-      type: "e2ee_message",
-      data: {
-        messageId: "7456191609143713633",
-        chatJid: "100042415119261.160@msgr",
-        senderJid: "100042415119261.160@msgr",
-        kind: "text",
-        text: "Hehe",
-        timestampMs: 1777694609888,
-      },
-    });
-  });
-
-  it("should preserve group chat JID and sender device for E2EE group messages", (done) => {
-    eventBus.on("e2ee_message", (data) => {
-      expect(data.threadId).toBe("1805602490133470@g.us");
-      expect(data.chatJid).toBe("1805602490133470@g.us");
-      expect(data.senderJid).toBe("100042415119261.101@msgr");
-      expect(data.senderId).toBe("100042415119261");
-      expect(data.senderDeviceId).toBe(101);
-      expect(data.isGroup).toBe(true);
-      expect(data.kind).toBe("text");
-      done();
-    });
-
-    mapper.emitMappedEvent({
-      type: "e2ee_message",
-      data: {
-        messageId: "m1",
-        chatJid: "1805602490133470@g.us",
-        senderJid: "100042415119261.101@msgr",
-        type: "text",
-        text: "hello group",
-      },
-    });
-  });
-
-  it("should route E2EE decrypt failures through catch-all without unhandled error", (done) => {
-    eventBus.on("event", (event) => {
-      expect(event.type).toBe("error");
-      expect(event.data.message).toContain("E2EE decrypt failed");
-      done();
-    });
-
-    expect(() => mapper.emitMappedEvent({
-      type: "e2ee_message",
-      data: {
-        type: "decryption_failed",
-        chatJid: "1805602490133470@g.us",
-        senderJid: "100042415119261.101@msgr",
-        error: "missing sender key state",
-      },
-    })).not.toThrow();
-  });
-
-
-  it("should mark E2EE connected and emit both typed and catch-all events", (done) => {
-    const seen: string[] = [];
-    eventBus.on("e2ee_connected", () => seen.push("typed"));
-    eventBus.on("event", (event) => {
-      if (event.type !== "e2ee_connected") return;
-      seen.push("catch-all");
-      expect(e2eeService.markConnected).toHaveBeenCalledTimes(1);
-      expect(seen).toEqual(["typed", "catch-all"]);
-      done();
-    });
-
-    mapper.emitMappedEvent({ type: "e2eeConnected" });
-  });
-
-  it("should infer E2EE media kind and preserve optional payload fields", (done) => {
-    eventBus.on("e2ee_message", (data) => {
-      expect(data.kind).toBe("image");
-      expect(data.media).toEqual({ type: "image", directPath: "/m" });
-      expect(data.reaction).toBe("🔥");
-      expect(data.targetId).toBe("mid.target");
-      expect(data.fromMe).toBe(true);
-      expect(data.replyTo).toEqual({ messageId: "mid.reply", senderId: "200" });
-      done();
-    });
-
-    mapper.emitMappedEvent({
-      type: "e2ee_message",
-      data: {
-        messageId: "mid.media",
-        chatJid: "100.0@msgr",
-        senderJid: "100.5@msgr",
-        media: { type: "image", directPath: "/m" },
-        emoji: "🔥",
-        targetId: "mid.target",
-        fromMe: true,
-        replyToId: "mid.reply",
-        replyToSenderJid: "200.9@msgr",
-      },
-    });
-  });
-
-  it("should emit typed error events when an error listener exists", (done) => {
-    let catchAllSeen = false;
-    eventBus.on("event", (event) => {
-      if (event.type === "error") catchAllSeen = true;
-    });
-    eventBus.on("error", (data) => {
-      expect(data.message).toBe("boom");
-      expect(catchAllSeen).toBe(false);
-      setImmediate(() => {
-        expect(catchAllSeen).toBe(true);
-        done();
-      });
-    });
-
-    mapper.emit({ type: "error", data: { message: "boom" } });
-  });
-
-});