fb-messenger-e2ee 0.1.0 → 0.1.2

package/tests/unit/e2ee/prekey-manager.test.ts

@@ -1,55 +0,0 @@
-import { DeviceStore } from "../../../src/e2ee/store/device-store.ts";
-import { generatePreKeys, generateSignedPreKey, buildPreKeyUploadPayload } from "../../../src/e2ee/signal/prekey-manager.ts";
-import * as path from "node:path";
-import * as os from "node:os";
-import * as fs from "node:fs";
-
-describe("prekey-manager", () => {
-  let store: DeviceStore;
-  let testPath: string;
-
-  beforeEach(async () => {
-    testPath = path.join(os.tmpdir(), `prekey-${Math.random().toString(36).slice(2)}.json`);
-    store = await DeviceStore.fromFile(testPath);
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(testPath)) {
-      fs.unlinkSync(testPath);
-    }
-  });
-
-  it("should generate a batch of prekeys", async () => {
-    const count = 5;
-    const keys = await generatePreKeys(store, count);
-    expect(keys.length).toBe(count);
-    expect(keys[0]).toBeDefined();
-    expect(keys[0]!.id).toBeDefined();
-    expect(keys[0]!.record).toBeDefined();
-    
-    // Check if saved in store
-    const record = await store.getPreKey(keys[0]!.id);
-    expect(record).toBeDefined();
-  });
-
-  it("should generate a signed prekey", async () => {
-    const record = await generateSignedPreKey(store);
-    expect(record.id()).toBeDefined();
-    expect(record.signature()).toBeDefined();
-    
-    // Check if saved in store
-    const saved = await store.getSignedPreKey(record.id());
-    expect(saved).toBeDefined();
-  });
-
-  it("should build an upload payload", async () => {
-    await generateSignedPreKey(store);
-    const preKeys = await generatePreKeys(store, 2);
-    const payload = await buildPreKeyUploadPayload(store, preKeys);
-    
-    expect(payload.registrationId).toBe(store.registrationId);
-    expect(payload.identityKey.length).toBe(33);
-    expect(payload.signedPreKey.keyId).toBeDefined();
-    expect(payload.preKeys.length).toBe(2);
-  });
-});

package/tests/unit/e2ee/wa-binary.test.ts

@@ -1,127 +0,0 @@
-import { BinaryDecoder, unmarshal, type Node, BinaryToken, encodePresenceAvailable, encodeKeepAlive, encodeSetPassive, encodePrimingNode, encodeIQ, encodePreKeyUpload, buildUnifiedSessionId, encodeNode, marshal } from "../../../src/e2ee/transport/binary/wa-binary.ts";
-
-describe("wa-binary", () => {
-  describe("unmarshal", () => {
-    it("should throw error on empty data", () => {
-      expect(() => unmarshal(Buffer.alloc(0))).toThrow("Empty data in unmarshal");
-    });
-
-    it("should unmarshal a simple node", () => {
-      // 0 = uncompressed, 248 1 = list of size 1, 3 = "s.whatsapp.net" token
-      const data = Buffer.from([0, 248, 1, 3]);
-      const node = unmarshal(data);
-      expect(node.tag).toBe("s.whatsapp.net");
-      expect(node.attrs).toEqual({});
-    });
-  });
-
-  describe("BinaryDecoder", () => {
-    it("should read dictionary tokens correctly", () => {
-      const data = Buffer.from([BinaryToken.Dictionary0, 1]);
-      const decoder = new BinaryDecoder(data);
-      // This depends on what's in Dictionary0, but we can at least check it doesn't throw
-      expect(() => decoder.readString(decoder.readByte())).not.toThrow();
-    });
-
-    it("should read JID pairs correctly", () => {
-      // JIDPair token, then user string, then server string
-      const data = Buffer.from([250, 252, 4, 117, 115, 101, 114, 3]); // user="user", server="s.whatsapp.net"
-      const decoder = new BinaryDecoder(data);
-      expect(decoder.read(true)).toBe("user@s.whatsapp.net");
-    });
-
-    it("should read FBJID correctly", () => {
-      // FBJID token, user, device(u16), server
-      const data = Buffer.from([246, 252, 4, 117, 115, 101, 114, 0, 10, 3]); // user="user", device=10, server="s.whatsapp.net"
-      const decoder = new BinaryDecoder(data);
-      expect(decoder.read(true)).toBe("user.10@s.whatsapp.net");
-    });
-    
-    it("should read packed8 nibbles correctly", () => {
-      // Nibble8 token, len byte (MSB=0 means even), packed nibbles
-      const data = Buffer.from([255, 2, 0x12, 0x34]); // "1234"
-      const decoder = new BinaryDecoder(data);
-      expect(decoder.read(true)).toBe("1234");
-    });
-  });
-
-  describe("stanza encoders", () => {
-    it("round-trips presence, keepalive, and passive stanzas", () => {
-      expect(unmarshal(encodePresenceAvailable("false"))).toMatchObject({
-        tag: "presence",
-        attrs: { type: "available", passive: "false" },
-      });
-
-      expect(unmarshal(encodeKeepAlive("ka-1"))).toMatchObject({
-        tag: "iq",
-        attrs: { id: "ka-1", type: "get", xmlns: "w:p" },
-      });
-
-      const passive = unmarshal(encodeSetPassive("passive-1", false));
-      expect(passive).toMatchObject({ tag: "iq", attrs: { id: "passive-1", type: "set", xmlns: "passive" } });
-      expect((passive.content as Node[])[0]!.tag).toBe("active");
-    });
-
-    it("builds deterministic unified session IDs within the weekly bucket", () => {
-      const id = buildUnifiedSessionId(10_000, 2_000);
-      expect(id).toBe(String((10_000 + 2_000 + 3 * 24 * 60 * 60 * 1000) % (7 * 24 * 60 * 60 * 1000)));
-    });
-
-
-
-    it("round-trips priming and generic IQ stanzas", () => {
-      const priming = unmarshal(encodePrimingNode("session-1"));
-      expect(priming.tag).toBe("ib");
-      expect(priming.attrs).toEqual({});
-      expect(priming.content).toEqual([
-        { tag: "unified_session", attrs: { id: "session-1" }, content: undefined },
-        { tag: "offline", attrs: {}, content: undefined },
-        { tag: "dirty", attrs: { type: "account_sync" }, content: undefined },
-      ]);
-
-      const iq = unmarshal(encodeIQ({ id: "iq-1", to: "s.whatsapp.net", type: "get", xmlns: "encrypt" }, [
-        encodeNode("count", {}, undefined),
-      ]));
-      expect(iq).toMatchObject({ tag: "iq", attrs: { id: "iq-1", type: "get", xmlns: "encrypt" } });
-      expect((iq.content as Node[])[0]).toMatchObject({ tag: "count", attrs: {} });
-    });
-
-    it("encodes prekey upload IQ with registration, identity, signed prekey, and one-time prekeys", () => {
-      const encoded = encodePreKeyUpload(0x01020304, Buffer.alloc(32, 1), {
-        id: 0x0a0b0c,
-        pubKey: Buffer.alloc(32, 2),
-        signature: Buffer.alloc(64, 3),
-      }, [
-        { id: 1, pubKey: Buffer.alloc(32, 4) },
-        { id: 2, pubKey: Buffer.alloc(32, 5) },
-      ]);
-
-      const iq = unmarshal(encoded);
-      const children = iq.content as Node[];
-      const registration = children.find(n => n.tag === "registration")!;
-      const type = children.find(n => n.tag === "type")!;
-      const identity = children.find(n => n.tag === "identity")!;
-      const list = children.find(n => n.tag === "list")!;
-      const skey = children.find(n => n.tag === "skey")!;
-
-      expect(iq).toMatchObject({ tag: "iq", attrs: { to: "s.whatsapp.net", type: "set", xmlns: "encrypt" } });
-      expect(registration.content).toEqual(Buffer.from([1, 2, 3, 4]));
-      expect(type.content).toEqual(Buffer.from([0x05]));
-      expect(identity.content).toEqual(Buffer.alloc(32, 1));
-      expect((list.content as Node[])).toHaveLength(2);
-      expect(((list.content as Node[])[0]!.content as Node[]).find(n => n.tag === "id")!.content).toEqual(Buffer.from([0, 0, 1]));
-      expect((skey.content as Node[]).find(n => n.tag === "id")!.content).toEqual(Buffer.from([0x0a, 0x0b, 0x0c]));
-      expect((skey.content as Node[]).find(n => n.tag === "signature")!.content).toEqual(Buffer.alloc(64, 3));
-    });
-
-    it("round-trips encoded nodes with Messenger JID attributes", () => {
-      const node = unmarshal(marshal(encodeNode("message", { to: "100.160@msgr", participant: "200:5@msgr", id: "m1" }, Buffer.from("body"))));
-
-      expect(node.tag).toBe("message");
-      expect(node.attrs.to).toBe("100.160@msgr");
-      expect(node.attrs.participant).toBe("200.5@msgr");
-      expect(node.content).toEqual(Buffer.from("body"));
-    });
-  });
-
-});

package/tests/unit/services/e2ee.service.test.ts

@@ -1,101 +0,0 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
-import { E2EEService } from "../../../src/services/e2ee.service.ts";
-import { decryptMedia, encryptMedia } from "../../../src/e2ee/media/media-crypto.ts";
-import type { MediaUploadConfig } from "../../../src/models/media.ts";
-
-const uploadConfig: MediaUploadConfig = { host: "upload.example", auth: "auth-token" };
-
-const createProvider = () => ({
-  encryptAndUploadMedia: jest.fn<(config: MediaUploadConfig, data: Buffer, type: string, mimeType: string) => Promise<unknown>>()
-    .mockResolvedValue({ directPath: "/m" }),
-  decryptMedia: jest.fn((opts: Parameters<typeof decryptMedia>[0]) => decryptMedia(opts)),
-});
-
-describe("E2EEService", () => {
-  const originalFetch = globalThis.fetch;
-  let service: E2EEService;
-  let provider: ReturnType<typeof createProvider>;
-
-  beforeEach(() => {
-    service = new E2EEService();
-    provider = createProvider();
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  it("guards access until a provider is connected", () => {
-    expect(service.isConnected).toBe(false);
-    expect(() => service.ensureEnabled()).toThrow("E2EE provider not connected");
-
-    service.markConnected();
-    expect(() => service.getClient()).toThrow("E2EE provider not connected");
-  });
-
-  it("stores the provider and exposes connection state", () => {
-    service.setProvider(provider as any, uploadConfig);
-
-    expect(service.isConnected).toBe(true);
-    expect(service.getClient()).toBe(provider);
-
-    service.markDisconnected();
-    expect(service.isConnected).toBe(false);
-    expect(() => service.ensureEnabled()).toThrow("E2EE provider not connected");
-  });
-
-  it.each([
-    ["sendImage", "image", "image/jpeg", { data: Buffer.from("image") }],
-    ["sendVideo", "video", "video/mp4", { data: Buffer.from("video") }],
-    ["sendAudio", "audio", "audio/ogg; codecs=opus", { data: Buffer.from("audio") }],
-    ["sendDocument", "document", "application/octet-stream", { data: Buffer.from("doc") }],
-    ["sendSticker", "image", "image/webp", { data: Buffer.from("sticker") }],
-  ] as const)("%s encrypts and uploads media with the expected defaults", async (method, type, mimeType, opts) => {
-    service.setProvider(provider as any, uploadConfig);
-
-    const result = await (service[method] as any)(opts);
-
-    expect(provider.encryptAndUploadMedia).toHaveBeenCalledWith(uploadConfig, opts.data, type, mimeType);
-    expect(result.messageId).toBe("mock-id");
-    expect(typeof result.timestampMs).toBe("number");
-  });
-
-  it("downloads and decrypts media using the selected media type", async () => {
-    const plaintext = Buffer.from("voice payload");
-    const encrypted = encryptMedia(plaintext, "audio");
-    globalThis.fetch = jest.fn(() => Promise.resolve({
-      ok: true,
-      arrayBuffer: () => Promise.resolve(encrypted.dataToUpload.buffer.slice(
-        encrypted.dataToUpload.byteOffset,
-        encrypted.dataToUpload.byteOffset + encrypted.dataToUpload.byteLength,
-      )),
-    })) as any;
-    service.setProvider(provider as any, uploadConfig);
-
-    const result = await service.downloadMedia({
-      directPath: "https://cdn.example/media",
-      mediaKey: encrypted.mediaKey.toString("base64"),
-      mediaSha256: encrypted.fileSHA256.toString("base64"),
-      mediaEncSha256: encrypted.fileEncSHA256.toString("base64"),
-      mediaType: "voice",
-      mimeType: "audio/ogg",
-    });
-
-    expect(globalThis.fetch).toHaveBeenCalledWith("https://cdn.example/media");
-    expect(provider.decryptMedia).toHaveBeenCalledWith(expect.objectContaining({ type: "audio" }));
-    expect(result).toEqual({ data: plaintext, mimeType: "audio/ogg", fileSize: plaintext.length });
-  });
-
-  it("throws when media download fails", async () => {
-    globalThis.fetch = jest.fn(() => Promise.resolve({ ok: false, status: 403 })) as any;
-    service.setProvider(provider as any, uploadConfig);
-
-    await expect(service.downloadMedia({
-      directPath: "https://cdn.example/forbidden",
-      mediaKey: Buffer.alloc(32).toString("base64"),
-      mediaSha256: Buffer.alloc(32).toString("base64"),
-      mediaType: "document",
-    })).rejects.toThrow("Failed to fetch media from CDN: 403");
-  });
-});

package/tests/unit/services/facebook-gateway.service.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { FacebookGatewayService } from "../../../src/services/facebook-gateway.service.ts";
-
-describe("FacebookGatewayService", () => {
-  let service: FacebookGatewayService;
-
-  beforeEach(() => {
-    service = new FacebookGatewayService();
-  });
-
-  it("configures FCA listening options", () => {
-    const api: any = { setOptions: jest.fn() };
-
-    service.configure(api);
-
-    expect(api.setOptions).toHaveBeenCalledWith(expect.objectContaining({
-      selfListen: false,
-      listenEvents: true,
-      autoMarkRead: false,
-      autoMarkDelivery: false,
-      online: true,
-    }));
-  });
-
-  it("starts MQTT listening and normalizes callback errors", async () => {
-    const event = { type: "message", body: "hi" };
-    const api: any = {
-      listenMqtt: jest.fn((callback: (err: unknown, event?: any) => void) => {
-        callback(null, event);
-        callback("boom");
-      }),
-    };
-    const onEvent = jest.fn();
-    const onError = jest.fn();
-
-    await service.startListening(api, onEvent, onError);
-
-    expect(onEvent).toHaveBeenCalledWith(event);
-    expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: "boom" }));
-  });
-
-  it("sends text, attachments, stickers, reactions, typing, read, and unsend through FCA", async () => {
-    const api: any = {
-      sendMessage: jest.fn().mockReturnValue({ messageID: "mid" }),
-      setMessageReaction: jest.fn(),
-      unsendMessage: jest.fn(),
-      sendTypingIndicator: jest.fn(),
-      markAsRead: jest.fn(),
-    };
-
-    await expect(service.sendMessage(api, "thread", "hello", "reply")).resolves.toEqual({ messageID: "mid" });
-    await expect(service.sendAttachmentMessage(api, {
-      threadId: "thread",
-      data: Buffer.from("abc"),
-      fileName: "a.txt",
-      caption: "cap",
-      replyToMessageId: "reply",
-    })).resolves.toEqual({ messageID: "mid" });
-    await expect(service.sendStickerMessage(api, { threadId: "thread", stickerId: 123, replyToMessageId: "reply" })).resolves.toEqual({ messageID: "mid" });
-    await service.sendReaction(api, "mid", "👍");
-    await service.unsendMessage(api, "mid");
-    await service.sendTyping(api, "thread", true);
-    await service.markAsRead(api, "thread");
-
-    expect(api.sendMessage).toHaveBeenNthCalledWith(1, "hello", "thread", undefined, "reply");
-    const attachmentPayload = api.sendMessage.mock.calls[1][0];
-    expect(attachmentPayload.body).toBe("cap");
-    expect(attachmentPayload.attachment.path).toBe("a.txt");
-    expect(api.sendMessage).toHaveBeenNthCalledWith(3, { sticker: 123 }, "thread", undefined, "reply");
-    expect(api.setMessageReaction).toHaveBeenCalledWith("👍", "mid", undefined, true);
-    expect(api.unsendMessage).toHaveBeenCalledWith("mid");
-    expect(api.sendTypingIndicator).toHaveBeenCalledWith(true, "thread");
-    expect(api.markAsRead).toHaveBeenCalledWith("thread", true);
-  });
-
-  it("throws clear errors when optional FCA methods are missing", async () => {
-    await expect(service.sendReaction({} as any, "mid", "👍")).rejects.toThrow("setMessageReaction is not available");
-    await expect(service.unsendMessage({} as any, "mid")).rejects.toThrow("unsendMessage is not available");
-    await expect(service.sendTyping({} as any, "thread", true)).rejects.toThrow("sendTypingIndicator is not available");
-    await expect(service.markAsRead({} as any, "thread")).rejects.toThrow("markAsRead is not available");
-  });
-
-  it("stops MQTT listening when available", () => {
-    const api: any = { stopListenMqtt: jest.fn() };
-    service.stop(api);
-    expect(api.stopListenMqtt).toHaveBeenCalled();
-  });
-
-  it("fetches CAT from GraphQL responses and rejects malformed responses", async () => {
-    const api: any = {
-      fb_dtsg: "token",
-      getCurrentUserID: jest.fn(() => "1001"),
-      httpPost: jest.fn().mockReturnValue('for (;;); {"data":{"secure_message_over_wa_cat_query":{"encrypted_serialized_cat":"cat-token"}}}'),
-    };
-
-    await expect(service.fetchCAT(api)).resolves.toBe("cat-token");
-    expect(api.httpPost).toHaveBeenCalledWith("https://www.facebook.com/api/graphql/", expect.objectContaining({
-      fb_dtsg: "token",
-      __user: "1001",
-      doc_id: "23999698219677129",
-    }));
-
-    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
-    try {
-      await expect(service.fetchCAT({ ...api, httpPost: jest.fn().mockReturnValue("not-json") })).rejects.toThrow("Failed to parse CAT response");
-      await expect(service.fetchCAT({ ...api, httpPost: jest.fn().mockReturnValue('{"data":{}}') })).rejects.toThrow("Failed to extract CAT token");
-    } finally {
-      errorSpy.mockRestore();
-    }
-  });
-
-  it("fetches and registers ICDC payloads through httpPost", async () => {
-    const api: any = {
-      getAppState: jest.fn(() => [{ key: "c_user", value: "1001" }]),
-      httpPost: jest.fn()
-        .mockReturnValueOnce('{"ok":true}')
-        .mockReturnValueOnce('{"registered":true}'),
-    };
-
-    await expect(service.fetchICDC(api, "1001", "42", Buffer.from("cat"))).resolves.toEqual({ ok: true });
-    expect(api.httpPost).toHaveBeenNthCalledWith(1, "https://reg-e2ee.facebook.com/v2/fb_icdc_fetch", expect.objectContaining({
-      fbid: "1001",
-      fb_cat: "cat",
-      device_id: "42",
-    }));
-
-    await expect(service.registerICDC(api, "1001", "42", Buffer.from("cat"), { payload: "x" })).resolves.toEqual({ registered: true });
-    expect(api.httpPost).toHaveBeenNthCalledWith(2, "https://reg-e2ee.facebook.com/v2/fb_register_v2", expect.objectContaining({
-      fbid: "1001",
-      fb_cat: Buffer.from("cat").toString("base64"),
-      device_id: "42",
-      payload: "x",
-    }));
-
-    await expect(service.fetchICDC({} as any, "1", "2", Buffer.from("cat"))).rejects.toThrow("api.httpPost is required");
-    await expect(service.registerICDC({} as any, "1", "2", Buffer.from("cat"), {})).rejects.toThrow("api.httpPost is required");
-  });
-});

package/tests/unit/services/media.service.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, jest, afterEach } from "@jest/globals";
-import * as http from "node:http";
-import { MediaService } from "../../../src/services/media.service.ts";
-
-describe("MediaService", () => {
-  const gateway = {
-    sendAttachmentMessage: jest.fn<(api: any, input: any) => Promise<Record<string, unknown>>>(),
-    sendStickerMessage: jest.fn<(api: any, input: any) => Promise<Record<string, unknown>>>(),
-  };
-  const service = new MediaService(gateway as any);
-  const api: any = {};
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it.each(["sendImage", "sendVideo", "sendAudio", "sendFile"] as const)(
-    "%s delegates attachment send to the gateway",
-    async (method) => {
-      gateway.sendAttachmentMessage.mockResolvedValue({ messageID: "mid.1" });
-
-      const result = await service[method](api, {
-        threadId: "thread-1",
-        data: Buffer.from("file"),
-        fileName: "file.bin",
-        caption: "caption",
-        replyToMessageId: "reply-1",
-      } as any);
-
-      expect(result).toEqual({ messageID: "mid.1" });
-      expect(gateway.sendAttachmentMessage).toHaveBeenCalledWith(api, {
-        threadId: "thread-1",
-        data: Buffer.from("file"),
-        fileName: "file.bin",
-        caption: "caption",
-        replyToMessageId: "reply-1",
-      });
-    },
-  );
-
-  it("sendSticker delegates to the gateway", async () => {
-    gateway.sendStickerMessage.mockResolvedValue({ messageID: "mid.sticker" });
-
-    await expect(service.sendSticker(api, {
-      threadId: "thread-1",
-      stickerId: "123",
-      replyToMessageId: "reply-1",
-    } as any)).resolves.toEqual({ messageID: "mid.sticker" });
-
-    expect(gateway.sendStickerMessage).toHaveBeenCalledWith(api, {
-      threadId: "thread-1",
-      stickerId: "123",
-      replyToMessageId: "reply-1",
-    });
-  });
-
-  it("normalizes supported attachment shapes", () => {
-    expect(service.normalizeAttachment({
-      type: "image",
-      url: "https://cdn/image",
-      filename: "a.png",
-      mimeType: "image/png",
-      fileSize: "10",
-      mediaKey: "mk",
-      mediaSha256: "sha",
-      mediaEncSha256: "encsha",
-      directPath: "/mms/a",
-      width: "640",
-      height: 480,
-      thumbnailUrl: "https://cdn/thumb",
-    })).toMatchObject({
-      type: "image",
-      url: "https://cdn/image",
-      fileName: "a.png",
-      mimeType: "image/png",
-      fileSize: 10,
-      mediaKey: "mk",
-      mediaSha256: "sha",
-      mediaEncSha256: "encsha",
-      directPath: "/mms/a",
-      width: 640,
-      height: 480,
-      previewUrl: "https://cdn/thumb",
-    });
-
-    expect(service.normalizeAttachment({ type: "video", durationMs: "42", width: 1, height: 2 })).toMatchObject({
-      type: "video",
-      duration: 42,
-      width: 1,
-      height: 2,
-    });
-    expect(service.normalizeAttachment({ type: "voice", duration: "7" })).toMatchObject({ type: "voice", duration: 7 });
-    expect(service.normalizeAttachment({ type: "sticker", stickerID: "99" })).toMatchObject({ type: "sticker", stickerID: 99 });
-    expect(service.normalizeAttachment({ type: "location", latitude: "10.5", longitude: "20.5" })).toMatchObject({
-      type: "location",
-      latitude: 10.5,
-      longitude: 20.5,
-    });
-    expect(service.normalizeAttachment({ type: "link", description: "desc", source: "src", previewUrl: "p" })).toMatchObject({
-      type: "link",
-      description: "desc",
-      sourceText: "src",
-      previewUrl: "p",
-    });
-    expect(service.normalizeAttachment({ type: "unknown", name: "x.bin" })).toMatchObject({ type: "file", fileName: "x.bin" });
-    expect(service.normalizeAttachment(null)).toBeNull();
-    expect(service.normalizeAttachment({})).toBeNull();
-  });
-
-  it("downloads media bytes over HTTP", async () => {
-    const server = http.createServer((_req, res) => res.end(Buffer.from("downloaded")));
-    await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
-    const address = server.address();
-    if (!address || typeof address === "string") throw new Error("missing test server address");
-
-    try {
-      await expect(service.downloadMedia({ url: `http://127.0.0.1:${address.port}/file` })).resolves.toEqual(Buffer.from("downloaded"));
-    } finally {
-      await new Promise<void>(resolve => server.close(() => resolve()));
-    }
-  });
-
-  it("delegates thread management APIs and reports unavailable FCA methods", async () => {
-    const fullApi: any = {
-      muteThread: jest.fn(),
-      setTitle: jest.fn(),
-      changeGroupImage: jest.fn(),
-      deleteThread: jest.fn(),
-    };
-
-    await service.muteThread(fullApi, { threadId: "t", muteSeconds: 60 });
-    await service.renameThread(fullApi, { threadId: "t", newName: "new" });
-    await service.setGroupPhoto(fullApi, { threadId: "t", data: Buffer.from("img"), mimeType: "image/png" });
-    await service.deleteThread(fullApi, { threadId: "t" });
-
-    expect(fullApi.muteThread).toHaveBeenCalledWith("t", 60);
-    expect(fullApi.setTitle).toHaveBeenCalledWith("new", "t");
-    expect(fullApi.changeGroupImage).toHaveBeenCalledWith(Buffer.from("img"), "t");
-    expect(fullApi.deleteThread).toHaveBeenCalledWith("t");
-    await expect(service.muteThread({} as any, { threadId: "t", muteSeconds: 1 })).rejects.toThrow("muteThread not available");
-  });
-
-  it("maps FCA search and user info responses", async () => {
-    const searchApi: any = {
-      searchUsers: jest.fn().mockReturnValue([{ "1": { name: "Alice", firstName: "A", vanity: "alice", thumbSrc: "pic", gender: 2 } }]),
-      getUserInfo: jest.fn().mockReturnValue({ "1": { name: "Alice", firstName: "A", vanity: "alice", thumbSrc: "pic", gender: 2 } }),
-    };
-
-    await expect(service.searchUsers(searchApi, { query: "ali" })).resolves.toEqual([{
-      id: "1",
-      name: "Alice",
-      firstName: "A",
-      username: "alice",
-      profilePictureUrl: "pic",
-      gender: 2,
-    }]);
-    await expect(service.getUserInfo(searchApi, { userId: "1" })).resolves.toMatchObject({ id: "1", name: "Alice" });
-    await expect(service.searchUsers({ searchUsers: jest.fn().mockReturnValue(null) } as any, { query: "x" })).resolves.toEqual([]);
-    await expect(service.getUserInfo({ getUserInfo: jest.fn().mockReturnValue({}) } as any, { userId: "2" })).resolves.toBeNull();
-  });
-
-  it("creates a thread through FCA when available and falls back to the user ID", async () => {
-    const createApi: any = { createNewGroup: jest.fn().mockReturnValue({ threadID: "thread-new" }) };
-
-    await expect(service.createThread(createApi, { userId: "1001" })).resolves.toMatchObject({ id: "thread-new", type: 1 });
-    expect(createApi.createNewGroup).toHaveBeenCalledWith(["1001"], "", undefined);
-    await expect(service.createThread({} as any, { userId: "1001" })).resolves.toMatchObject({ id: "1001", type: 1 });
-  });
-});

package/tests/unit/utils/fca-utils.test.ts

@@ -1,48 +0,0 @@
-import { str, num, date } from "../../../src/utils/fca-utils.ts";
-
-describe("fca-utils", () => {
-  describe("str", () => {
-    it("should return string as is", () => {
-      expect(str("hello")).toBe("hello");
-    });
-    it("should convert number to string", () => {
-      expect(str(123)).toBe("123");
-    });
-    it("should convert boolean to string", () => {
-      expect(str(true)).toBe("true");
-    });
-    it("should return empty string for null/undefined", () => {
-      expect(str(null)).toBe("");
-      expect(str(undefined)).toBe("");
-    });
-  });
-
-  describe("num", () => {
-    it("should return number as is", () => {
-      expect(num(123)).toBe(123);
-    });
-    it("should convert string to number", () => {
-      expect(num("123")).toBe(123);
-    });
-    it("should return 0 for invalid numbers", () => {
-      expect(num("abc")).toBe(0);
-      expect(num(null)).toBe(0);
-    });
-  });
-
-  describe("date", () => {
-    it("should return timestamp from Date object", () => {
-      const d = new Date();
-      expect(date(d)).toBe(d.getTime());
-    });
-    it("should parse date string", () => {
-      const s = "2023-01-01T00:00:00Z";
-      expect(date(s)).toBe(new Date(s).getTime());
-    });
-    it("should return current time for invalid input", () => {
-      const now = Date.now();
-      const result = date("invalid");
-      expect(result).toBeGreaterThanOrEqual(now);
-    });
-  });
-});

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "types": ["bun", "jest"]
-  },
-  "include": ["src/**/*.ts", "src/**/*.d.ts", "tests/**/*.ts"]
-}