fb-messenger-e2ee 0.1.1 → 0.1.2

package/src/e2ee/transport/noise/noise-handshake.ts

@@ -1,417 +0,0 @@
-/**
- * E2EE Noise Handshake - Layer 1 (Transport)
- *
- * Implements Noise_XX_25519_AESGCM_SHA256 - the transport layer handshake
- * used by WhatsApp/Messenger before any Signal Protocol messages.
- *
- * Flow:
- *   1. Client -> Server: ClientHello { ephemeral: EphemeralPub }
- *   2. Server -> Client: ServerHello { ephemeral, static(enc), payload(enc=cert) }
- *   3. Client -> Server: ClientFinish { static(enc=NoiseKey.Pub), payload(enc=ClientPayload) }
- *   -> Both sides derive sendKey + recvKey for AES-256-GCM frame encryption
- */
-
-import {
-  createCipheriv,
-  createDecipheriv,
-  createHash,
-  hkdfSync,
-  randomBytes,
-  generateKeyPairSync,
-  createPublicKey,
-  createPrivateKey,
-  diffieHellman,
-} from "node:crypto";
-import { inflateSync } from "node:zlib";
-import type { HandshakeResult, NoiseSocket, RawWebSocket } from "../../../models/e2ee.ts";
-import { logger } from "../../../utils/logger.ts";
-export type { HandshakeResult, NoiseSocket, RawWebSocket };
-
-// X25519 Helpers using node:crypto
-const SPKI_HEADER = Buffer.from("302a300506032b656e032100", "hex");
-const PKCS8_HEADER = Buffer.from("302e020100300506032b656e04220420", "hex");
-
-export function generateX25519(): { priv: Buffer; pub: Buffer } {
-  const { privateKey, publicKey } = generateKeyPairSync("x25519");
-  const privRaw = privateKey.export({ type: "pkcs8", format: "der" });
-  const pubRaw = publicKey.export({ type: "spki", format: "der" });
-  return {
-    priv: Buffer.from(privRaw.subarray(privRaw.length - 32)),
-    pub: Buffer.from(pubRaw.subarray(pubRaw.length - 32)),
-  };
-}
-
-export function getX25519PublicKey(privKeyRaw: Buffer): Buffer {
-  const priv = createPrivateKey({ key: Buffer.concat([PKCS8_HEADER, privKeyRaw]), format: "der", type: "pkcs8" });
-  const pubDer = createPublicKey(priv).export({ type: "spki", format: "der" });
-  return Buffer.from(pubDer.subarray(pubDer.length - 32));
-}
-
-export function x25519DH(privKeyRaw: Buffer, pubKeyRaw: Buffer): Buffer {
-  const pub = createPublicKey({ key: Buffer.concat([SPKI_HEADER, pubKeyRaw]), format: "der", type: "spki" });
-  const priv = createPrivateKey({ key: Buffer.concat([PKCS8_HEADER, privKeyRaw]), format: "der", type: "pkcs8" });
-  return diffieHellman({ privateKey: priv, publicKey: pub });
-}
-
-// Hardcoded protocol constants
-
-// Root certificate public key - Ed25519, 32 bytes
-export const WA_CERT_PUB_KEY = Buffer.from(
-  "142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b",
-  "hex",
-);
-
-// Noise handshake protocol name (WA variant)
-const NOISE_START_PATTERN = Buffer.from("Noise_XX_25519_AESGCM_SHA256\0\0\0\0");
-
-// WA header sent at the start of every connection (version + magic bytes)
-export const WA_HEADER = Buffer.from([87, 65, 6, 3]); // "WA\x06\x03"
-
-// Noise state machine helpers
-
-class NoiseHandshakeState {
-  private h: Buffer;       // hash (chaining key / handshake hash)
-  private ck: Buffer;      // chaining key
-  private k: Buffer | null = null;   // current symmetric key
-  private n = 0;           // nonce counter
-
-  constructor(startPattern: Buffer, header: Buffer) {
-    // If protocol_name is exactly 32 bytes, h = protocol_name
-    if (startPattern.length === 32) {
-      this.h = Buffer.from(startPattern);
-    } else {
-      this.h = this.sha256(startPattern);
-    }
-    this.ck = this.h;
-    // h = SHA256(h ‖ prologue)
-    this.mixHash(header);
-  }
-
-  private sha256(data: Buffer): Buffer {
-    return Buffer.from(createHash("sha256").update(data).digest());
-  }
-
-  mixHash(data: Buffer): void {
-    this.h = this.sha256(Buffer.concat([this.h, data]));
-  }
-
-  mixKey(input: Buffer): void {
-    // HKDF-SHA256(ck, input) -> ck', k
-    const expanded = Buffer.from(hkdfSync("sha256", input, this.ck, "", 64));
-    this.ck = expanded.subarray(0, 32);
-    this.k = expanded.subarray(32, 64);
-    this.n = 0;
-    // logger.debug("noise-handshake", `mixKey -> ck=${this.ck.toString("hex").slice(0, 8)} k=${this.k.toString("hex").slice(0, 8)}`);
-  }
-
-  mixSharedSecretIntoKey(privKey: Buffer, pubKey: Buffer): void {
-    const sharedSecret = x25519DH(privKey, pubKey);
-    this.mixKey(sharedSecret);
-  }
-
-  /** AES-256-GCM encrypt; ad = current h; updates h */
-  encrypt(plaintext: Buffer): Buffer {
-    if (!this.k) throw new Error("No key set in Noise state");
-    const nonce = this.buildNonce(this.n++);
-    const cipher = createCipheriv("aes-256-gcm", this.k, nonce);
-    cipher.setAAD(this.h);
-    const enc = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
-    this.mixHash(enc);
-    return enc;
-  }
-
-  /** AES-256-GCM decrypt; ad = current h; updates h */
-  decrypt(ciphertext: Buffer): Buffer {
-    if (!this.k) throw new Error("No key set in Noise state");
-    const nonce = this.buildNonce(this.n++);
-    const tag = ciphertext.subarray(-16);
-    const body = ciphertext.subarray(0, -16);
-    try {
-      const decipher = createDecipheriv("aes-256-gcm", this.k, nonce);
-      decipher.setAAD(this.h);
-      decipher.setAuthTag(tag);
-      const plain = Buffer.concat([decipher.update(body), decipher.final()]);
-      this.mixHash(ciphertext);
-      return plain;
-    } catch (err) {
-      logger.error("CipherState", `Decrypt error at n=${this.n - 1}:`, err);
-      logger.error("CipherState", `  - Key: ${this.k.toString('hex')}`);
-      logger.error("CipherState", `  - Nonce: ${nonce.toString('hex')}`);
-      logger.error("CipherState", `  - AAD: ${this.h.toString('hex')}`);
-      throw err;
-    }
-  }
-
-  /** Derive final send/recv keys from the completed handshake */
-  finish(): { sendKey: Buffer; recvKey: Buffer } {
-    const expanded = Buffer.from(hkdfSync("sha256", Buffer.alloc(0), this.ck, Buffer.alloc(0), 64));
-    return {
-      sendKey: expanded.subarray(0, 32),
-      recvKey: expanded.subarray(32, 64),
-    };
-  }
-
-  get handshakeHash(): Buffer { return this.h; }
-
-  private buildNonce(counter: number): Buffer {
-    const nonce = Buffer.alloc(12);
-    nonce.writeUInt32BE(counter, 8);
-    return nonce;
-  }
-}
-
-function verifyCertChain(certChainRaw: Buffer, serverStaticPub: Buffer): void {
-  // Placeholder - full cert chain verification requires waCert proto parser.
-  // Trust established via Noise shared-secret derivation instead.
-  void certChainRaw;
-  void serverStaticPub;
-  // TODO: Implement full cert chain verification in production
-}
-
-// Noise handshake + frame socket
-
-
-/** Encrypted frame socket backed by established Noise keys */
-class EncryptedFrameSocket implements NoiseSocket {
-  private ws: RawWebSocket;
-  private sendKey: Buffer;
-  private recvKey: Buffer;
-  private sendCounter: number = 0;
-  private recvCounter: number = 0;
-
-  constructor(ws: RawWebSocket, sendKey: Buffer, recvKey: Buffer) {
-    this.ws = ws;
-    this.sendKey = sendKey;
-    this.recvKey = recvKey;
-  }
-
-  private buildNonce(counter: number): Buffer {
-    const n = Buffer.alloc(12);
-    n.writeBigUInt64BE(BigInt(counter), 4);
-    return n;
-  }
-
-  private encryptFrame(plaintext: Buffer): Buffer {
-    const nonce = this.buildNonce(this.sendCounter++);
-    const cipher = createCipheriv("aes-256-gcm", this.sendKey, nonce);
-    const enc = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
-
-    // Prefix with 3-byte big-endian length
-    const header = Buffer.alloc(3);
-    header.writeUIntBE(enc.length, 0, 3);
-
-    const fullFrame = Buffer.concat([header, enc]);
-    logger.debug("noise-handshake", `Sending frame (${fullFrame.length} bytes): ${fullFrame.toString("hex").slice(0, 32)}...`);
-    return fullFrame;
-  }
-
-  private decryptFrame(data: Buffer): Buffer {
-    if (data.length <= 16) {
-      // Keep-alive or too short to be an encrypted frame
-      return Buffer.alloc(0);
-    }
-    const nonce = this.buildNonce(this.recvCounter++);
-    const tag = data.subarray(-16);
-    const body = data.subarray(0, -16);
-    const decipher = createDecipheriv("aes-256-gcm", this.recvKey, nonce);
-    decipher.setAuthTag(tag);
-
-    return Buffer.concat([decipher.update(body), decipher.final()]);
-  }
-
-  async sendFrame(data: Buffer): Promise<void> {
-    this.ws.send(this.encryptFrame(data));
-  }
-
-  async readFrame(): Promise<Buffer> {
-    const header = await this.ws.readRaw(3);
-    if (!header) {
-      throw new Error("Socket closed while reading frame header");
-    }
-    const len = header.readUIntBE(0, 3);
-    logger.debug("FacebookE2EESocket", `RAW frame header: ${header.toString('hex')} (len=${len})`);
-
-    const payload = await this.ws.readRaw(len);
-    try {
-      const decrypted = this.decryptFrame(payload);
-      logger.debug("FacebookE2EESocket", `Decrypt successful, result length: ${decrypted.length}`);
-      return decrypted;
-    } catch (err) {
-      logger.error("FacebookE2EESocket", "Decrypt FAILED:", err);
-      throw err;
-    }
-  }
-
-  close(): void { this.ws.close(); }
-}
-
-// Public API: doHandshake
-
-
-/**
- * Perform the Noise XX handshake with the WhatsApp/Messenger server.
- *
- * @param ws         Raw WebSocket (caller handles connection)
- * @param noiseKeyPriv  32-byte Noise private key from DeviceStore
- * @param clientPayload Serialized ClientPayload protobuf (device identity)
- */
-export async function doHandshake(
-  ws: RawWebSocket,
-  noiseKeyPriv: Buffer,
-  clientPayload: Buffer,
-): Promise<HandshakeResult> {
-  const state = new NoiseHandshakeState(NOISE_START_PATTERN, WA_HEADER);
-
-  // Generate ephemeral X25519 keypair using node:crypto
-  const eph = generateX25519();
-  const ephPriv = eph.priv;
-  const ephPub = eph.pub;
-  logger.debug("debug", `ClientEphPriv: ${ephPriv.toString('hex')}`);
-  logger.debug("debug", `ClientEphPub:  ${ephPub.toString('hex')}`);
-
-  state.mixHash(ephPub);
-
-  // Step 1: Send ClientHello
-  // Proto: HandshakeMessage { clientHello: { ephemeral: ephPub } }
-  const clientHello = encodeHandshakeMessage({ clientHello: { ephemeral: ephPub } });
-  ws.send(prependHeader(clientHello));
-
-  // Step 2: Receive ServerHello
-  const serverHelloRaw = await readRawFrame(ws);
-  const serverHello = decodeServerHello(serverHelloRaw);
-
-  const serverEphPub = Buffer.from(serverHello.ephemeral);
-  const serverStaticEnc = Buffer.from(serverHello.static);
-  logger.debug("debug", `ServerStaticEnc: ${serverStaticEnc.toString('hex')}`);
-  const certEnc = Buffer.from(serverHello.payload);
-
-  logger.debug("noise-handshake", `Eph: ${serverEphPub.length}, StaticEnc: ${serverStaticEnc.length}, CertEnc: ${certEnc.length}`);
-
-  logger.debug("debug", `ServerEphPub:  ${serverEphPub.toString('hex')}`);
-  state.mixHash(serverEphPub);
-  state.mixSharedSecretIntoKey(ephPriv, serverEphPub);
-  logger.debug("debug", `After ServerHello mix: k=${state['k']?.toString('hex')}, h=${state['h']?.toString('hex')}`);
-
-  const serverStaticPub = state.decrypt(serverStaticEnc);
-  logger.debug("noise-handshake", `Decrypted Server Static Pub: ${serverStaticPub.toString("hex")}`);
-  state.mixSharedSecretIntoKey(ephPriv, serverStaticPub);
-
-  const certDecrypted = state.decrypt(certEnc);
-  verifyCertChain(certDecrypted, serverStaticPub);
-
-  // Step 3: Send ClientFinish
-  const noiseKeyPub = getX25519PublicKey(noiseKeyPriv);
-  const encNoisePub = state.encrypt(noiseKeyPub);
-  state.mixSharedSecretIntoKey(noiseKeyPriv, serverEphPub);
-
-  const encPayload = state.encrypt(clientPayload);
-  const clientFinish = encodeHandshakeMessage({
-    clientFinish: { static: encNoisePub, payload: encPayload },
-  });
-  const finishFrame = prependLength(clientFinish);
-  logger.debug("noise-handshake", `Sending clientFinish frame (${finishFrame.length} bytes): ${finishFrame.toString("hex").slice(0, 32)}...`);
-  ws.send(finishFrame);
-
-  // Derive final keys
-  const { sendKey, recvKey } = state.finish();
-
-  return {
-    socket: new EncryptedFrameSocket(ws, sendKey, recvKey),
-  };
-}
-
-// Minimal protobuf helpers for handshake messages
-
-function encodeHandshakeMessage(msg: {
-  clientHello?: { ephemeral: Buffer };
-  clientFinish?: { static: Buffer; payload: Buffer };
-}): Buffer {
-  // HandshakeMessage { field 2 = ClientHello { field 1 = ephemeral } }
-  // HandshakeMessage { field 4 = ClientFinish { field 1 = static, field 3 = payload } }
-  // Note: ClientFinish payload is field 3, not 2! (Wait, let me double check waProto.proto)
-  // Let me output the fix for HandshakeMessage first.
-  const chunks: Buffer[] = [];
-
-  if (msg.clientHello) {
-    const hello = encLenDelim(1, msg.clientHello.ephemeral);
-    chunks.push(encLenDelim(2, hello));
-  }
-  if (msg.clientFinish) {
-    const finish = Buffer.concat([
-      encLenDelim(1, msg.clientFinish.static),
-      encLenDelim(2, msg.clientFinish.payload),
-    ]);
-    chunks.push(encLenDelim(4, finish));
-  }
-
-  return Buffer.concat(chunks);
-}
-
-function decodeServerHello(data: Buffer): {
-  ephemeral: Buffer;
-  static: Buffer;
-  payload: Buffer;
-} {
-  // HandshakeMessage { field 3 = ServerHello { field 1 = ephemeral, field 2 = static, field 3 = payload } }
-  const serverHelloRaw = decodeLenDelim(data, 3);
-  return {
-    ephemeral: decodeLenDelim(serverHelloRaw, 1),
-    static: decodeLenDelim(serverHelloRaw, 2),
-    payload: decodeLenDelim(serverHelloRaw, 3),
-  };
-}
-
-// Tiny protobuf encoder helpers
-function encVarint(n: number): Buffer {
-  const bytes: number[] = [];
-  let v = n >>> 0;
-  while (v > 127) { bytes.push((v & 0x7f) | 0x80); v >>>= 7; }
-  bytes.push(v);
-  return Buffer.from(bytes);
-}
-
-function encLenDelim(field: number, data: Buffer): Buffer {
-  return Buffer.concat([encVarint((field << 3) | 2), encVarint(data.length), data]);
-}
-
-function decodeLenDelim(data: Buffer, targetField: number): Buffer {
-  let pos = 0;
-  while (pos < data.length) {
-    const tag = data[pos]!; pos++;
-    const field = tag >> 3;
-    const wire = tag & 0x07;
-    if (wire === 2) {
-      let len = 0, shift = 0;
-      while (true) {
-        const b = data[pos]!; pos++;
-        len |= (b & 0x7f) << shift;
-        if (!(b & 0x80)) break;
-        shift += 7;
-      }
-      const value = data.subarray(pos, pos + len); pos += len;
-      if (field === targetField) return Buffer.from(value);
-    } else if (wire === 0) {
-      while (pos < data.length && (data[pos]! & 0x80)) pos++;
-      pos++;
-    } else break;
-  }
-  throw new Error(`Field ${targetField} not found in handshake message`);
-}
-
-function prependHeader(data: Buffer): Buffer {
-  return Buffer.concat([WA_HEADER, prependLength(data)]);
-}
-
-function prependLength(data: Buffer): Buffer {
-  const header = Buffer.alloc(3);
-  header.writeUIntBE(data.length, 0, 3);
-  return Buffer.concat([header, data]);
-}
-
-async function readRawFrame(ws: RawWebSocket): Promise<Buffer> {
-  const header = await ws.readRaw(3);
-  const len = header.readUIntBE(0, 3);
-  const payload = await ws.readRaw(len);
-  logger.debug("noise-handshake", `Raw Frame received: header=${header.toString('hex')} (len=${len}), payload_head=${payload.toString('hex').slice(0, 32)}...`);
-  return payload;
-}

package/src/e2ee/transport/noise/noise-socket.ts

@@ -1,230 +0,0 @@
-import { EventEmitter } from "node:events";
-import { appendFileSync } from "node:fs";
-import { doHandshake } from "./noise-handshake.ts";
-import type { NoiseSocket, RawWebSocket } from "../../../models/e2ee.ts";
-import { encodeKeepAlive, unmarshal } from "../binary/wa-binary.ts";
-import { logger } from "../../../utils/logger.ts";
-
-export class FacebookE2EESocket extends EventEmitter {
-  private ws: WebSocket | null = null;
-  private noiseSocket: NoiseSocket | null = null;
-  private url: string;
-  private heartbeatInterval: any = null;
-  private isConnected: boolean = false;
-
-  constructor(endpoint: string) {
-    super();
-    this.url = endpoint;
-  }
-
-  public async connect(noisePrivKey: Buffer, authPayload: Buffer): Promise<void> {
-    return new Promise((resolve, reject) => {
-      try {
-        const wsUrl = new URL(this.url);
-        // Add chat specific query params if needed
-        wsUrl.searchParams.set("cid", "client-" + Date.now());
-
-        const UserAgentStr = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
-
-        this.ws = new (WebSocket as any)(wsUrl.toString(), undefined, {
-          headers: {
-            "Origin": "https://www.facebook.com",
-            "User-Agent": UserAgentStr,
-          }
-        });
-        this.ws!.binaryType = "arraybuffer";
-
-        let handshakeResolved = false;
-        let streamBuffer: Buffer[] = [];
-        let streamLen = 0;
-        let waitingResolver: ((data: Buffer) => void) | null = null;
-        let waitingLen: number = 0;
-
-        this.ws!.addEventListener("message", (ev) => {
-          const frame = Buffer.from(ev.data as ArrayBuffer);
-          streamBuffer.push(frame);
-          streamLen += frame.length;
-          if (waitingResolver && streamLen >= waitingLen) {
-            const res = waitingResolver;
-            const len = waitingLen;
-            waitingResolver = null;
-            waitingLen = 0;
-            res(readFromBuffer(len));
-          }
-        });
-
-        function readFromBuffer(len: number): Buffer {
-          let res = Buffer.alloc(len);
-          let offset = 0;
-          while (offset < len && streamBuffer.length > 0) {
-            const first = streamBuffer[0];
-            const remaining = len - offset;
-            if (first && first.length <= remaining) {
-              first.copy(res, offset);
-              offset += first.length;
-              streamBuffer.shift();
-            } else if (first) {
-              first.copy(res, offset, 0, remaining);
-              streamBuffer[0] = first.subarray(remaining);
-              offset += remaining;
-            } else {
-              break;
-            }
-          }
-          streamLen -= len;
-          return res;
-        }
-
-        const rawWs: RawWebSocket = {
-          send: (data: Buffer) => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-              this.ws.send(data);
-            }
-          },
-          readRaw: (len?: number): Promise<Buffer> => {
-            const targetLen = len || 0;
-            if (targetLen === 0) {
-              if (streamLen > 0) return Promise.resolve(readFromBuffer(streamLen));
-              return new Promise((resolve) => {
-                waitingLen = 1;
-                waitingResolver = () => resolve(readFromBuffer(streamLen));
-              });
-            }
-            if (streamLen >= targetLen) {
-              return Promise.resolve(readFromBuffer(targetLen));
-            }
-            if (this.ws?.readyState !== WebSocket.OPEN) {
-              return Promise.reject(new Error("WebSocket not open"));
-            }
-            return new Promise((resolve) => {
-              waitingLen = targetLen;
-              waitingResolver = resolve;
-            });
-          },
-          close: () => this.ws?.close(),
-        };
-
-        this.ws!.addEventListener("close", () => {
-          this.isConnected = false;
-          this.stopHeartbeat();
-          if (waitingResolver) {
-            waitingResolver(null as any);
-            waitingResolver = null;
-          }
-          this.emit("disconnected");
-        });
-
-        this.ws!.addEventListener("open", async () => {
-          try {
-            const { socket } = await doHandshake(rawWs, noisePrivKey, authPayload);
-            this.noiseSocket = socket;
-            handshakeResolved = true;
-            this.isConnected = true;
-            this.emit("connected");
-            resolve();
-            this.startReading();
-            this.startHeartbeat();
-          } catch (err) {
-            reject(err);
-            this.ws?.close();
-          }
-        });
-
-        this.ws!.addEventListener("error", (ev) => {
-          if (!handshakeResolved) reject(new Error("WebSocket error"));
-          this.emit("error", ev);
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  private startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatInterval = setInterval(async () => {
-      try {
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          logger.debug("NoiseSocket", "Sending Noise heartbeat (0,0,0)...");
-          this.ws.send(Buffer.from([0, 0, 0]));
-        }
-
-      } catch (err) {
-        logger.error("FacebookE2EESocket", "Heartbeat failed:", err);
-      }
-    }, 15000);
-  }
-
-  private stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-
-  private async startReading(): Promise<void> {
-    if (!this.noiseSocket) return;
-    try {
-      while (this.isConnected && this.noiseSocket) {
-        logger.debug("FacebookE2EESocket", "Waiting for frame...");
-        const frame = await this.noiseSocket.readFrame();
-        if (frame && frame.length > 0) {
-          try {
-            logger.debug("FacebookE2EESocket", `Unmarshaling frame (${frame.length} bytes)...`);
-            const node = unmarshal(frame);
-            logger.debug("FacebookE2EESocket", `Decrypted node: <${node.tag}>`, JSON.stringify(node.attrs, null, 2));
-            if (node.content) {
-              logger.debug("FacebookE2EESocket", `Node content type: ${Array.isArray(node.content) ? "Array[" + node.content.length + "]" : typeof node.content}`);
-            }
-          } catch (e) {
-            logger.error("FacebookE2EESocket", `Received decrypted frame (${frame.length} bytes), but failed to unmarshal: ${e}`);
-            logger.debug("FacebookE2EESocket", `Frame hex: ${frame.toString("hex").slice(0, 100)}`);
-          }
-          this.emit("frame", frame);
-        } else if (frame) {
-          // Heartbeat or empty frame from server
-          logger.debug("FacebookE2EESocket", "Received empty frame (heartbeat from server)");
-        }
-      }
-    } catch (err) {
-      if (!this.isConnected) {
-        logger.debug("FacebookE2EESocket", "Read loop stopped after intentional socket close");
-        return;
-      }
-      logger.error("FacebookE2EESocket", "Read loop stopped due to error:", err);
-      this.isConnected = false;
-      this.emit("error", err);
-    }
-  }
-
-  public async sendFrame(data: Buffer): Promise<void> {
-    if (!this.noiseSocket) throw new Error("Socket not connected");
-    try {
-      const node = unmarshal(data);
-      logger.debug("NoiseSocket", `Sending encrypted node: <${node.tag}>`, JSON.stringify(node.attrs, null, 2));
-      try {
-        const record = { ts: Date.now(), tag: node.tag, attrs: node.attrs, hex: data.toString("hex") };
-        appendFileSync("./outbound_frames.log", JSON.stringify(record) + "\n");
-      } catch (e) {
-        logger.debug("NoiseSocket", "Failed to write outbound frame log:", e);
-      }
-    } catch (e) {
-      logger.debug("NoiseSocket", `Sending raw encrypted frame (${data.length} bytes)`);
-      try {
-        const record = { ts: Date.now(), tag: null, attrs: null, hex: data.toString("hex") };
-        appendFileSync("./outbound_frames.log", JSON.stringify(record) + "\n");
-      } catch (e) {
-        logger.debug("NoiseSocket", "Failed to write outbound frame log:", e);
-      }
-    }
-    await this.noiseSocket.sendFrame(data);
-  }
-
-
-  public close(): void {
-    this.isConnected = false;
-    this.stopHeartbeat();
-    this.noiseSocket?.close();
-    this.ws?.close();
-  }
-}

package/src/index.ts

@@ -1,34 +0,0 @@
-export { FBClient } from "./core/client.ts";
-export { E2EEService } from "./services/e2ee.service.ts";
-
-export type { ClientOptions, SessionData, MessengerEventMap } from "./models/client.ts";
-export type { AuthConfig, AppEnv } from "./models/config.ts";
-export type {
-  Attachment,
-  Mention,
-  ReplyTo,
-  Platform,
-  MessengerEvent,
-  E2EEMessage,
-  E2EEMessageKind,
-} from "./models/domain.ts";
-export type {
-  SendMessageInput,
-  SendMediaInput,
-  SendReactionInput,
-  TypingInput,
-} from "./models/messaging.ts";
-export type {
-  E2EESendTextOptions,
-  E2EESendTextResult,
-  E2EEEncryptMediaOptions,
-  E2EEEncryptMediaResult,
-  E2EEDecryptMediaOptions,
-  E2EEDownloadOptions,
-  E2EEDownloadResult,
-} from "./models/e2ee.ts";
-export type {
-  MediaUploadConfig,
-  MediaUploadResult,
-  MmsTypeStr,
-} from "./models/media.ts";