fb-messenger-e2ee 0.1.1 → 0.1.2

package/src/services/icdc.service.ts

@@ -1,177 +0,0 @@
-import { createHash } from "node:crypto";
-import { PrivateKey } from "@signalapp/libsignal-client";
-import { encodeICDCIdentityList, encodeSignedICDCIdentityList } from "../e2ee/facebook/icdc-payload.ts";
-import type { DeviceStore } from "../e2ee/store/device-store.ts";
-import { logger } from "../utils/logger.ts";
-
-export interface ICDCFetchResponse {
-  device_identities: string[];
-  icdc_seq: number;
-  status: number;
-}
-
-export interface ICDCRegisterResponse {
-  icdc_success?: boolean;
-  product?: string;
-  status: number;
-  type?: string;
-  wa_device_id: number;
-}
-
-export class ICDCService {
-  private readonly baseUrl = "https://reg-e2ee.facebook.com/v2";
-  private readonly origin = "https://www.messenger.com";
-  private readonly referer = "https://www.messenger.com/messages/";
-  private cookies: string = "";
-
-  constructor(
-    private readonly userAgent: string,
-    initialCookies?: string,
-  ) {
-    if (initialCookies) this.cookies = initialCookies;
-  }
-
-  public setCookies(cookies: string): void {
-    this.cookies = cookies;
-  }
-
-  public async register(
-    fbid: string,
-    fbCat: string,
-    appId: string,
-    deviceStore: DeviceStore,
-  ): Promise<number> {
-    logger.debug("ICDCService", "Starting ICDC registration...");
-
-    // Fetch current ICDC state
-    const fetchResp = await this.fetchICDC(fbid, deviceStore.facebookUUID, appId, fbCat);
-    if (fetchResp.status !== 200) {
-      throw new Error(`ICDC fetch failed with status ${fetchResp.status}`);
-    }
-
-    const deviceIdentities = fetchResp.device_identities.map((id) =>
-      Buffer.from(id, "base64")
-    );
-
-    // Check if our own identity is already there
-    const ownIdentityPub = deviceStore.getIdentityPublicKey();
-    let ownIdentityIndex = deviceIdentities.findIndex((id) =>
-      Buffer.compare(id, ownIdentityPub) === 0
-    );
-
-    let nextSeq = fetchResp.icdc_seq;
-    if (ownIdentityIndex === -1) {
-      logger.debug("ICDCService", "Own identity not found in list, adding...");
-      ownIdentityIndex = deviceIdentities.length;
-      deviceIdentities.push(Buffer.from(ownIdentityPub));
-      nextSeq++;
-    } else {
-      logger.debug("ICDCService", `Own identity found at index ${ownIdentityIndex}`);
-    }
-
-    const icdcTs = Math.floor(Date.now() / 1000);
-
-    // Build and sign ICDC Identity List
-    const unsignedList = encodeICDCIdentityList({
-      seq: nextSeq,
-      timestamp: icdcTs,
-      devices: deviceIdentities,
-      signingDeviceIndex: ownIdentityIndex,
-    });
-
-    const privKey = PrivateKey.deserialize(Buffer.from(deviceStore.getIdentityPrivateKey()));
-    const signature = Buffer.from(privKey.sign(unsignedList));
-
-    const signedList = encodeSignedICDCIdentityList({
-      details: unsignedList,
-      signature: signature,
-    });
-
-    // Register
-    const identitiesHash = this.calculateIdentitiesHash(deviceIdentities);
-
-    const form = new URLSearchParams();
-    form.set("fbid", fbid);
-    form.set("fb_cat", fbCat);
-    form.set("app_id", appId);
-    form.set("device_id", deviceStore.facebookUUID);
-
-    // Registration ID: big-endian uint32
-    const regIdBuf = Buffer.alloc(4);
-    regIdBuf.writeUInt32BE(deviceStore.registrationId);
-    form.set("e_regid", regIdBuf.toString("base64"));
-
-    form.set("e_keytype", Buffer.from([0x05]).toString("base64")); // DJB_TYPE
-    form.set("e_ident", ownIdentityPub.toString("base64"));
-
-    // Signed Prekey ID: big-endian uint24 (last 3 bytes of uint32)
-    const skeyIdBuf = Buffer.alloc(4);
-    skeyIdBuf.writeUInt32BE(deviceStore.signedPreKeyId);
-    form.set("e_skey_id", skeyIdBuf.subarray(1).toString("base64"));
-
-    form.set("e_skey_val", deviceStore.getSignedPreKeyPublicKey().toString("base64"));
-    form.set("e_skey_sig", deviceStore.signedPreKeySig.toString("base64"));
-
-    form.set("icdc_list", signedList.toString("base64"));
-    form.set("icdc_ts", icdcTs.toString());
-    form.set("icdc_seq", nextSeq.toString());
-    form.set("ihash", identitiesHash.toString("base64"));
-
-    const registerResp = await this.post<ICDCRegisterResponse>(
-      "fb_register_v2",
-      form
-    );
-
-    if (registerResp.status !== 200) {
-      throw new Error(`ICDC register failed with status ${registerResp.status}`);
-    }
-
-    logger.info("ICDCService", `ICDC registration successful. WA Device ID: ${registerResp.wa_device_id}`);
-    return registerResp.wa_device_id;
-  }
-
-  private async fetchICDC(fbid: string, facebookUUID: string, appId: string, fbCat: string): Promise<ICDCFetchResponse> {
-    const form = new URLSearchParams();
-    form.set("fbid", fbid);
-    form.set("device_id", facebookUUID);
-    form.set("app_id", appId);
-    form.set("fb_cat", fbCat);
-
-    return this.post<ICDCFetchResponse>("fb_icdc_fetch", form);
-  }
-
-  private async post<T>(endpoint: string, body: URLSearchParams): Promise<T> {
-    const url = `${this.baseUrl}/${endpoint}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
-        "Accept-Language": "en-US,en;q=0.9",
-        "User-Agent": this.userAgent,
-        "Origin": this.origin,
-        "Referer": this.referer,
-        "Cookie": this.cookies,
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "cross-site",
-      },
-      body: body.toString(),
-    });
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`HTTP error ${response.status}: ${text}`);
-    }
-
-    return response.json() as Promise<T>;
-  }
-
-  private calculateIdentitiesHash(identities: Buffer[]): Buffer {
-    const sorted = [...identities].sort(Buffer.compare);
-    const hash = createHash("sha256");
-    for (const identity of sorted) {
-      hash.update(identity);
-    }
-    return hash.digest().subarray(0, 10);
-  }
-}

package/src/services/media.service.ts

@@ -1,304 +0,0 @@
-import * as https from "node:https";
-import * as http from "node:http";
-import { str, num } from "../utils/fca-utils.ts";
-
-
-import type { FCAApi } from "fca-unofficial";
-
-import type {
-  Attachment,
-  BaseAttachment,
-  Thread,
-  UserInfo,
-} from "../models/domain.ts";
-import type {
-  CreateThreadInput,
-  DeleteThreadInput,
-  DownloadMediaInput,
-  GetUserInfoInput,
-  MarkReadInput,
-  MuteThreadInput,
-  RenameThreadInput,
-  SearchUsersInput,
-  SendMediaInput,
-  SendStickerInput,
-  SetGroupPhotoInput,
-} from "../models/messaging.ts";
-import type { MediaUploadResult } from "../models/media.ts";
-import { FacebookGatewayService } from "./facebook-gateway.service.ts";
-
-export class MediaService {
-  public constructor(private readonly gateway: FacebookGatewayService) { }
-
-  // Media send
-
-  public async sendImage(
-    api: FCAApi,
-    input: SendMediaInput,
-  ): Promise<Record<string, unknown>> {
-    return this.gateway.sendAttachmentMessage(api, {
-      threadId: input.threadId,
-      data: input.data,
-      fileName: input.fileName,
-      caption: input.caption,
-      replyToMessageId: input.replyToMessageId,
-    });
-  }
-
-  public async sendVideo(
-    api: FCAApi,
-    input: SendMediaInput,
-  ): Promise<Record<string, unknown>> {
-    return this.gateway.sendAttachmentMessage(api, {
-      threadId: input.threadId,
-      data: input.data,
-      fileName: input.fileName,
-      caption: input.caption,
-      replyToMessageId: input.replyToMessageId,
-    });
-  }
-
-  public async sendAudio(
-    api: FCAApi,
-    input: SendMediaInput,
-  ): Promise<Record<string, unknown>> {
-    return this.gateway.sendAttachmentMessage(api, {
-      threadId: input.threadId,
-      data: input.data,
-      fileName: input.fileName,
-      caption: input.caption,
-      replyToMessageId: input.replyToMessageId,
-    });
-  }
-
-  public async sendFile(
-    api: FCAApi,
-    input: SendMediaInput,
-  ): Promise<Record<string, unknown>> {
-    return this.gateway.sendAttachmentMessage(api, {
-      threadId: input.threadId,
-      data: input.data,
-      fileName: input.fileName,
-      caption: input.caption,
-      replyToMessageId: input.replyToMessageId,
-    });
-  }
-
-  public async sendSticker(
-    api: FCAApi,
-    input: SendStickerInput,
-  ): Promise<Record<string, unknown>> {
-    return this.gateway.sendStickerMessage(api, {
-      threadId: input.threadId,
-      stickerId: input.stickerId,
-      replyToMessageId: input.replyToMessageId,
-    });
-  }
-
-  // Media download
-
-  /**
-   * Downloads raw bytes from a Facebook CDN URL.
-   * Uses Node's built-in https/http since fca-unofficial does not expose a
-   * dedicated download API at the JS level (unlike the Go messagix client).
-   */
-  public async downloadMedia(input: DownloadMediaInput): Promise<Buffer> {
-    return downloadUrl(input.url);
-  }
-
-  // Attachment normalisation helper (used by client controller)
-
-  public normalizeAttachment(item: unknown): Attachment | null {
-    if (typeof item !== "object" || item === null) {
-      return null;
-    }
-    const att = item as Record<string, unknown>;
-    const type = typeof att.type === "string" ? att.type : "";
-    if (!type) return null;
-
-    const base: BaseAttachment = {
-      url: str(att.url ?? att.previewUrl ?? att.largePreviewUrl),
-      fileName: str(att.filename ?? att.name),
-      mimeType: str(att.mimeType),
-      fileSize: num(att.fileSize),
-      mediaKey: str(att.mediaKey) || undefined,
-      mediaSha256: str(att.mediaSha256) || undefined,
-      mediaEncSha256: str(att.mediaEncSha256) || undefined,
-      directPath: str(att.directPath) || undefined,
-    };
-
-    switch (type) {
-      case "image":
-      case "gif":
-      case "photo":
-        return {
-          ...base,
-          type,
-          width: num(att.width),
-          height: num(att.height),
-          previewUrl: str(att.thumbnailUrl ?? att.previewUrl),
-        };
-      case "video":
-        return {
-          ...base,
-          type,
-          width: num(att.width),
-          height: num(att.height),
-          duration: num(att.duration ?? att.durationMs),
-          previewUrl: str(att.thumbnailUrl ?? att.previewUrl),
-        };
-      case "audio":
-      case "voice":
-        return {
-          ...base,
-          type,
-          duration: num(att.duration ?? att.durationMs),
-        };
-      case "sticker":
-        return {
-          ...base,
-          type,
-          stickerID: num(att.stickerID),
-        };
-      case "location":
-        return {
-          ...base,
-          type,
-          latitude: num(att.latitude),
-          longitude: num(att.longitude),
-        };
-      case "link":
-        return {
-          ...base,
-          type,
-          description: str(att.description),
-          sourceText: str(att.source),
-          previewUrl: str(att.thumbnailUrl ?? att.previewUrl),
-        };
-      default:
-        return {
-          ...base,
-          type: "file",
-        };
-    }
-  }
-
-  // Thread / group management (mirrors bridge-go media.go)
-
-  public async muteThread(api: FCAApi, input: MuteThreadInput): Promise<void> {
-    if (!api.muteThread) {
-      throw new Error("muteThread not available in fca-unofficial");
-    }
-    await Promise.resolve(api.muteThread(input.threadId, input.muteSeconds));
-  }
-
-  public async renameThread(
-    api: FCAApi,
-    input: RenameThreadInput,
-  ): Promise<void> {
-    if (!api.setTitle) {
-      throw new Error("setTitle not available in fca-unofficial");
-    }
-    await Promise.resolve(api.setTitle(input.newName, input.threadId));
-  }
-
-  public async setGroupPhoto(
-    api: FCAApi,
-    input: SetGroupPhotoInput,
-  ): Promise<void> {
-    if (!api.changeGroupImage) {
-      throw new Error("changeGroupImage not available in fca-unofficial");
-    }
-    // fca-unofficial accepts a Readable stream or Buffer for the image
-    await Promise.resolve(api.changeGroupImage(input.data, input.threadId));
-  }
-
-  public async deleteThread(
-    api: FCAApi,
-    input: DeleteThreadInput,
-  ): Promise<void> {
-    if (!api.deleteThread) {
-      throw new Error("deleteThread not available in fca-unofficial");
-    }
-    await Promise.resolve(api.deleteThread(input.threadId));
-  }
-
-  // User / search (mirrors bridge-go media.go SearchUsers / GetUserInfo / CreateThread)
-
-  public async searchUsers(
-    api: FCAApi,
-    input: SearchUsersInput,
-  ): Promise<UserInfo[]> {
-    if (!api.searchUsers) {
-      throw new Error("searchUsers not available in fca-unofficial");
-    }
-    const raw = await Promise.resolve(api.searchUsers(input.query));
-    if (!raw) return [];
-    // fca-unofficial returns an array of {[id]: FriendInfo} objects
-    const entries = Array.isArray(raw)
-      ? (raw as Record<string, unknown>[]).flatMap(item => Object.entries(item))
-      : Object.entries(raw as Record<string, unknown>);
-    return entries.map(([id, infoRaw]) => {
-      const info = infoRaw as { name?: string; firstName?: string; vanity?: string; thumbSrc?: string; gender?: number };
-      return {
-        id,
-        name: info.name ?? "",
-        firstName: info.firstName,
-        username: info.vanity,
-        profilePictureUrl: info.thumbSrc,
-        gender: info.gender,
-      };
-    });
-  }
-
-  public async getUserInfo(
-    api: FCAApi,
-    input: GetUserInfoInput,
-  ): Promise<UserInfo | null> {
-    if (!api.getUserInfo) {
-      throw new Error("getUserInfo not available in fca-unofficial");
-    }
-    const raw = await Promise.resolve(api.getUserInfo(input.userId));
-    if (!raw) return null;
-    const info = raw[input.userId];
-    if (!info) return null;
-    return {
-      id: input.userId,
-      name: info.name ?? "",
-      firstName: info.firstName,
-      username: info.vanity,
-      profilePictureUrl: info.thumbSrc,
-      gender: info.gender,
-    };
-  }
-
-  public async createThread(
-    api: FCAApi,
-    input: CreateThreadInput,
-  ): Promise<Thread> {
-    // fca-unofficial createNewGroup with a single user creates a DM-like thread
-    if (!api.createNewGroup) {
-      // Fallback: treat the userId as the threadId (1:1 DM convention)
-      return { id: input.userId, type: 1, name: "", lastActivityTimestampMs: Date.now() };
-    }
-    const result = await Promise.resolve(
-      api.createNewGroup([input.userId], "", undefined),
-    );
-    const threadId = str((result as Record<string, unknown>)?.threadID ?? input.userId) || input.userId;
-    return { id: threadId, type: 1, name: "", lastActivityTimestampMs: Date.now() };
-  }
-}
-
-// Internal helpers
-
-function downloadUrl(url: string): Promise<Buffer> {
-  return new Promise((resolve, reject) => {
-    const mod = url.startsWith("https") ? https : http;
-    mod.get(url, (res: any) => {
-      const chunks: Buffer[] = [];
-      res.on("data", (chunk: Buffer) => chunks.push(chunk));
-      res.on("end", () => resolve(Buffer.concat(chunks)));
-      res.on("error", reject);
-    }).on("error", reject);
-  });
-}

package/src/services/messaging.service.ts

@@ -1,28 +0,0 @@
-import type { FCAApi } from "fca-unofficial";
-
-import type { MarkReadInput, SendMessageInput, SendReactionInput, TypingInput } from "../models/messaging.ts";
-import { FacebookGatewayService } from "./facebook-gateway.service.ts";
-
-export class MessagingService {
-  public constructor(private readonly gateway: FacebookGatewayService) {}
-
-  public async sendText(api: FCAApi, input: SendMessageInput): Promise<Record<string, unknown>> {
-    return this.gateway.sendMessage(api, input.threadId, input.text, input.replyToMessageId);
-  }
-
-  public async react(api: FCAApi, input: SendReactionInput): Promise<void> {
-    await this.gateway.sendReaction(api, input.messageId, input.reaction);
-  }
-
-  public async unsend(api: FCAApi, messageId: string): Promise<void> {
-    await this.gateway.unsendMessage(api, messageId);
-  }
-
-  public async sendTyping(api: FCAApi, input: TypingInput): Promise<void> {
-    await this.gateway.sendTyping(api, input.threadId, input.isTyping);
-  }
-
-  public async markAsRead(api: FCAApi, input: MarkReadInput): Promise<void> {
-    await this.gateway.markAsRead(api, input.threadId);
-  }
-}

package/src/services/thread.service.ts

@@ -1,199 +0,0 @@
-import type { FCAApi, HistoryMessage, ThreadListItem } from "fca-unofficial";
-
-import type {
-  Attachment,
-  MessengerMessage,
-  Thread,
-  UserInfo,
-} from "../models/domain.ts";
-import type {
-  AddGroupMemberInput,
-  ChangeAdminStatusInput,
-  CreatePollInput,
-  EditMessageInput,
-  EditMessageResult,
-  ForwardAttachmentInput,
-  GetThreadHistoryInput,
-  GetThreadListInput,
-  RemoveGroupMemberInput,
-  ThreadDetails,
-} from "../models/thread.ts";
-import type { MediaService } from "./media.service.ts";
-
-
-// ThreadService
-
-export class ThreadService {
-  public constructor(private readonly mediaService: MediaService) { }
-
-  // Thread list
-
-  public async getThreadList(
-    api: FCAApi,
-    input: GetThreadListInput,
-  ): Promise<ThreadDetails[]> {
-    if (!api.getThreadList) {
-      throw new Error("getThreadList not available in fca-unofficial");
-    }
-    const tags = input.folder ? [input.folder] : [""];
-    const raw = await Promise.resolve(
-      api.getThreadList(input.limit, input.beforeTimestamp ?? null, tags),
-    );
-    if (!raw) return [];
-    return (raw as ThreadListItem[]).map(t => this.mapThread(t));
-  }
-
-  // Thread history
-
-  public async getThreadHistory(
-    api: FCAApi,
-    input: GetThreadHistoryInput,
-  ): Promise<MessengerMessage[]> {
-    if (!api.getThreadHistory) {
-      throw new Error("getThreadHistory not available in fca-unofficial");
-    }
-    const raw = await Promise.resolve(
-      api.getThreadHistory(
-        input.threadId,
-        input.amount,
-        input.beforeTimestamp,
-      ),
-    );
-    if (!raw) return [];
-    return (raw as HistoryMessage[]).map(m => this.mapHistoryMessage(m));
-  }
-
-  // Forward attachment
-
-  public async forwardAttachment(
-    api: FCAApi,
-    input: ForwardAttachmentInput,
-  ): Promise<void> {
-    if (!api.forwardAttachment) {
-      throw new Error("forwardAttachment not available in fca-unofficial");
-    }
-    await Promise.resolve(
-      api.forwardAttachment(input.attachmentId, input.threadIds),
-    );
-  }
-
-  // Poll
-
-  public async createPoll(api: FCAApi, input: CreatePollInput): Promise<void> {
-    if (!api.createPoll) {
-      throw new Error("createPoll not available in fca-unofficial");
-    }
-    await Promise.resolve(
-      api.createPoll(input.title, input.threadId, input.options ?? {}),
-    );
-  }
-
-  // Edit message (non-E2EE; uses MQTT internally)
-
-  public async editMessage(
-    api: FCAApi,
-    input: EditMessageInput,
-  ): Promise<EditMessageResult> {
-    if (!api.editMessage) {
-      throw new Error("editMessage not available in fca-unofficial");
-    }
-    const res = await Promise.resolve(
-      api.editMessage(input.newText, input.messageId),
-    );
-    const r = (res ?? {}) as Record<string, unknown>;
-    return {
-      messageId: typeof r["messageID"] === "string" ? r["messageID"] : input.messageId,
-      newText: typeof r["body"] === "string" ? r["body"] : input.newText,
-    };
-  }
-
-  // Group member management
-
-  public async addGroupMember(
-    api: FCAApi,
-    input: AddGroupMemberInput,
-  ): Promise<void> {
-    if (!api.addUserToGroup) {
-      throw new Error("addUserToGroup not available in fca-unofficial");
-    }
-    const ids = input.userIds.length === 1 ? (input.userIds[0] ?? "") : input.userIds;
-    await Promise.resolve(api.addUserToGroup(ids, input.threadId));
-  }
-
-  public async removeGroupMember(
-    api: FCAApi,
-    input: RemoveGroupMemberInput,
-  ): Promise<void> {
-    if (!api.removeUserFromGroup) {
-      throw new Error("removeUserFromGroup not available in fca-unofficial");
-    }
-    await Promise.resolve(api.removeUserFromGroup(input.userId, input.threadId));
-  }
-
-  public async changeAdminStatus(
-    api: FCAApi,
-    input: ChangeAdminStatusInput,
-  ): Promise<void> {
-    if (!api.changeAdminStatus) {
-      throw new Error("changeAdminStatus not available in fca-unofficial");
-    }
-    await Promise.resolve(
-      api.changeAdminStatus(input.threadId, input.userId, input.isAdmin),
-    );
-  }
-
-  // Friends list
-
-  public async getFriendsList(api: FCAApi): Promise<UserInfo[]> {
-    if (!api.getFriendsList) {
-      throw new Error("getFriendsList not available in fca-unofficial");
-    }
-    const raw = await Promise.resolve(api.getFriendsList());
-    if (!raw) return [];
-    return Object.entries(raw).map(([id, info]) => ({
-      id,
-      name: info.name ?? "",
-      firstName: info.firstName,
-      username: info.vanity,
-      profilePictureUrl: info.thumbSrc,
-      gender: info.gender,
-    }));
-  }
-
-  // Private helpers
-
-  private mapThread(t: ThreadListItem): ThreadDetails {
-    return {
-      id: t.threadID,
-      type: t.threadType,
-      name: t.name ?? "",
-      lastActivityTimestampMs: t.timestamp ? Number(t.timestamp) : 0,
-      snippet: t.snippet,
-      unreadCount: t.unreadCount,
-      messageCount: t.messageCount,
-      emoji: t.emoji,
-      muteUntil: t.muteUntil,
-      participantIds: t.participantIDs,
-      adminIds: t.adminIDs,
-      isArchived: t.isArchived,
-      folder: t.folder,
-    };
-  }
-
-  private mapHistoryMessage(m: HistoryMessage): MessengerMessage {
-    const attachments = Array.isArray(m.attachments) && m.attachments.length > 0
-      ? m.attachments
-        .map(a => this.mediaService.normalizeAttachment(a))
-        .filter((a): a is Attachment => a !== null)
-      : undefined;
-
-    return {
-      id: m.messageID,
-      threadId: m.threadID,
-      senderId: m.senderID,
-      text: m.body ?? "",
-      timestampMs: m.timestamp ? Number(m.timestamp) : 0,
-      attachments: attachments && attachments.length > 0 ? attachments : undefined,
-    };
-  }
-}