fb-messenger-e2ee 0.1.0

package/tests/integration.test.ts

@@ -0,0 +1,498 @@
+/**
+ * Integration tests for fbE2EE - runs with Bun test runner (bun test).
+ *
+ * These tests use in-memory fixture data and do NOT hit Facebook's servers.
+ * They verify that:
+ *   - domain mapping (attachment normalisation, mention mapping, event mapping) is correct
+ *   - service-level methods behave correctly given a stubbed FCAApi
+ *   - ClientController correctly wires services and emits typed events
+ */
+
+import { EventEmitter } from "node:events";
+import { expect, mock, test, describe, beforeEach } from "bun:test";
+
+// ---- Source under test -------------------------------------------------------
+import type { FCAApi } from "fca-unofficial";
+import { ClientController } from "../src/controllers/client.controller.ts";
+import type { MessengerEvent, MessengerMessage } from "../src/models/domain.ts";
+import { AuthService } from "../src/services/auth.service.ts";
+import { E2EEService } from "../src/services/e2ee.service.ts";
+import { FacebookGatewayService } from "../src/services/facebook-gateway.service.ts";
+import { MediaService } from "../src/services/media.service.ts";
+import { MessagingService } from "../src/services/messaging.service.ts";
+import { ThreadService } from "../src/services/thread.service.ts";
+import { ICDCService } from "../src/services/icdc.service.ts";
+
+// ---- Fixture factories -------------------------------------------------------
+
+function makeFakeApi(overrides: Partial<FCAApi> = {}): FCAApi {
+  return {
+    getCurrentUserID: () => "123456",
+    getAppState: () => [],
+    setOptions: () => undefined,
+    listenMqtt: async () => undefined,
+    sendMessage: async () => ({ messageID: "mid.001", timestamp: 1_700_000_000_000 }),
+    setMessageReaction: async () => undefined,
+    unsendMessage: async () => undefined,
+    sendTypingIndicator: async () => undefined,
+    markAsRead: async () => undefined,
+    stopListenMqtt: () => undefined,
+    muteThread: async () => undefined,
+    setTitle: async () => undefined,
+    deleteThread: async () => undefined,
+    getThreadList: async () => [],
+    getThreadHistory: async () => [],
+    createPoll: async () => undefined,
+    editMessage: async () => ({ messageID: "mid.001", body: "edited" }),
+    addUserToGroup: async () => undefined,
+    removeUserFromGroup: async () => undefined,
+    changeAdminStatus: async () => undefined,
+    getUserInfo: async () => ({
+      "123456": { name: "Test User", firstName: "Test", vanity: "testuser", thumbSrc: "", gender: 1 },
+    }),
+    searchUsers: async () => [] as Record<string, import("fca-unofficial").FriendInfo>[],
+    createNewGroup: async () => ({ threadID: "t.001" }),
+    ...overrides,
+  };
+}
+
+function makeServices() {
+  const gateway = new FacebookGatewayService();
+  const mediaService = new MediaService(gateway);
+  const messagingService = new MessagingService(gateway);
+  const threadService = new ThreadService(mediaService);
+  const authService = new AuthService({ readSession: async () => null, saveSession: async () => undefined } as unknown as ConstructorParameters<typeof AuthService>[0]);
+  const e2eeService = new E2EEService();
+  const icdcService = new ICDCService("test-agent");
+  const eventBus = new EventEmitter();
+  const controller = new ClientController(
+    authService,
+    gateway,
+    mediaService,
+    e2eeService,
+    icdcService,
+    eventBus,
+  );
+  return { gateway, mediaService, messagingService, threadService, e2eeService, eventBus, controller };
+}
+
+// =============================================================================
+// MediaService - attachment normalisation
+// =============================================================================
+
+describe("MediaService.normalizeAttachment", () => {
+  const { mediaService } = makeServices();
+
+  test("returns null for non-object", () => {
+    expect(mediaService.normalizeAttachment(null)).toBeNull();
+    expect(mediaService.normalizeAttachment("bad")).toBeNull();
+    expect(mediaService.normalizeAttachment(42)).toBeNull();
+  });
+
+  test("returns null when type is missing", () => {
+    expect(mediaService.normalizeAttachment({})).toBeNull();
+  });
+
+  test("maps image attachment", () => {
+    const raw = {
+      type: "photo",
+      url: "https://cdn.fb.com/img.jpg",
+      previewUrl: "https://cdn.fb.com/thumb.jpg",
+      width: 1920,
+      height: 1080,
+      mimeType: "image/jpeg",
+      fileSize: 204800,
+    };
+    const att = mediaService.normalizeAttachment(raw);
+    expect(att).not.toBeNull();
+    if (att?.type !== "photo") throw new Error("Expected photo attachment");
+    expect(att.url).toBe("https://cdn.fb.com/img.jpg");
+    expect(att.width).toBe(1920);
+    expect(att.height).toBe(1080);
+  });
+
+  test("maps audio attachment with duration", () => {
+    const raw = {
+      type: "audio",
+      url: "https://cdn.fb.com/audio.mp3",
+      mimeType: "audio/mpeg",
+      duration: 30,
+      fileSize: 512000,
+    };
+    const att = mediaService.normalizeAttachment(raw);
+    if (att?.type !== "audio") throw new Error("Expected audio attachment");
+    expect(att.duration).toBe(30);
+  });
+
+  test("maps sticker attachment", () => {
+    const raw = { type: "sticker", url: "https://cdn.fb.com/sticker.png", stickerID: 369239263222822 };
+    const att = mediaService.normalizeAttachment(raw);
+    expect(att!.type).toBe("sticker");
+  });
+
+  test("maps location attachment", () => {
+    const raw = { type: "location", latitude: 10.123, longitude: 106.456 };
+    const att = mediaService.normalizeAttachment(raw);
+    if (att?.type !== "location") throw new Error("Expected location attachment");
+    expect(att.latitude).toBe(10.123);
+    expect(att.longitude).toBe(106.456);
+  });
+});
+
+// =============================================================================
+// MediaService - downloadMedia
+// =============================================================================
+
+describe("MediaService.downloadMedia", () => {
+  const { mediaService } = makeServices();
+
+  test("throws on unreachable URL without crashing process", async () => {
+    // Point at localhost:1 - guaranteed to refuse connection quickly
+    await expect(
+      mediaService.downloadMedia({ url: "http://127.0.0.1:1/file.bin" }),
+    ).rejects.toThrow();
+  });
+});
+
+// =============================================================================
+// MessagingService
+// =============================================================================
+
+describe("MessagingService.sendText", () => {
+  const { messagingService } = makeServices();
+
+  test("calls api.sendMessage and returns result", async () => {
+    const api = makeFakeApi();
+    const result = await messagingService.sendText(api, {
+      threadId: "t.001",
+      text: "Hello",
+    });
+    expect(result).toBeDefined();
+  });
+
+  test("passes replyToMessageId through", async () => {
+    let capturedReply: string | undefined;
+    const api = makeFakeApi({
+      sendMessage: (async (_msg: unknown, _tid: string, _cb: unknown, replyTo?: string) => {
+        capturedReply = replyTo;
+        return { messageID: "mid.002" };
+      }) as FCAApi["sendMessage"],
+    });
+    await messagingService.sendText(api, {
+      threadId: "t.001",
+      text: "Reply",
+      replyToMessageId: "mid.000",
+    });
+    expect(capturedReply).toBe("mid.000");
+  });
+});
+
+// =============================================================================
+// ThreadService
+// =============================================================================
+
+describe("ThreadService.getThreadList", () => {
+  const { threadService } = makeServices();
+
+  test("returns empty array when fca returns empty", async () => {
+    const api = makeFakeApi({ getThreadList: async () => [] });
+    const result = await threadService.getThreadList(api, { limit: 10 });
+    expect(result).toEqual([]);
+  });
+
+  test("throws when getThreadList not available", async () => {
+    const api = makeFakeApi({ getThreadList: undefined });
+    await expect(
+      threadService.getThreadList(api, { limit: 10 }),
+    ).rejects.toThrow("getThreadList not available");
+  });
+});
+
+describe("ThreadService.createPoll", () => {
+  test("calls createPoll on api", async () => {
+    const { threadService } = makeServices();
+    let called = false;
+    const api = makeFakeApi({
+      createPoll: async () => {
+        called = true;
+      },
+    });
+    await threadService.createPoll(api, {
+      threadId: "t.001",
+      title: "Favourite fruit?",
+      options: { Apple: false, Mango: true },
+    });
+    expect(called).toBe(true);
+  });
+
+  test("throws when createPoll not available", async () => {
+    const { threadService } = makeServices();
+    const api = makeFakeApi({ createPoll: undefined });
+    await expect(
+      threadService.createPoll(api, { threadId: "t.001", title: "Poll" }),
+    ).rejects.toThrow("createPoll not available");
+  });
+});
+
+describe("ThreadService.editMessage", () => {
+  test("returns edited message info", async () => {
+    const { threadService } = makeServices();
+    const api = makeFakeApi({
+      editMessage: async () => ({ messageID: "mid.999", body: "new text" }),
+    });
+    const result = await threadService.editMessage(api, {
+      messageId: "mid.999",
+      newText: "new text",
+    });
+    expect(result.messageId).toBe("mid.999");
+    expect(result.newText).toBe("new text");
+  });
+});
+
+describe("ThreadService.forwardAttachment", () => {
+  test("calls forwardAttachment on api", async () => {
+    const { threadService } = makeServices();
+    let capturedAttId: string | undefined;
+    let capturedTargets: string[] | undefined;
+    const api = makeFakeApi({
+      forwardAttachment: async (attachmentID: string, targets: string | string[]) => {
+        capturedAttId = attachmentID;
+        capturedTargets = Array.isArray(targets) ? targets : [targets];
+      },
+    });
+    await threadService.forwardAttachment(api, {
+      attachmentId: "att.001",
+      threadIds: ["t.001", "t.002"],
+    });
+    expect(capturedAttId).toBe("att.001");
+    expect(capturedTargets).toEqual(["t.001", "t.002"]);
+  });
+});
+
+// =============================================================================
+// E2EEService - contract/stub
+// =============================================================================
+
+describe("E2EEService stubs", () => {
+  test("isConnected starts false", () => {
+    const svc = new E2EEService();
+    expect(svc.isConnected).toBe(false);
+  });
+
+  test("markConnected/Disconnected toggles state", () => {
+    const svc = new E2EEService();
+    svc.markConnected();
+    expect(svc.isConnected).toBe(true);
+    svc.markDisconnected();
+    expect(svc.isConnected).toBe(false);
+  });
+
+  test("sendImage throws", async () => {
+    const svc = new E2EEService();
+    await expect(
+      svc.sendImage({ chatJid: "x@s.whatsapp.net", data: Buffer.alloc(1) }),
+    ).rejects.toThrow("E2EE provider not connected");
+  });
+
+  test("downloadMedia throws", async () => {
+    const svc = new E2EEService();
+    await expect(
+      svc.downloadMedia({
+        directPath: "/path",
+        mediaKey: "key",
+        mediaSha256: "sha",
+        mediaType: "image",
+      }),
+    ).rejects.toThrow("E2EE provider not connected");
+  });
+});
+
+// =============================================================================
+// ClientController - event mapping
+// =============================================================================
+
+describe("ClientController event mapping", () => {
+  function collectEvents(controller: ClientController, eventBus: EventEmitter): MessengerEvent[] {
+    const events: MessengerEvent[] = [];
+    eventBus.on("event", (e: MessengerEvent) => events.push(e));
+
+    // Expose internal emitMappedEvent via the test harness:
+    // We invoke connect() with a mocked API that captures the listener callback,
+    // then call it directly.
+    return events;
+  }
+
+  // Helper to directly fire a raw event through the controller's private mapper.
+  function fireRaw(controller: ClientController, raw: Record<string, unknown>): void {
+    const testController = controller as unknown as {
+      eventMapper: { emitMappedEvent(rawEvent: Record<string, unknown>): void };
+    };
+    testController.eventMapper.emitMappedEvent(raw);
+  }
+
+  test("maps standard message event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "message",
+      messageID: "mid.1",
+      threadID: "t.1",
+      senderID: "u.1",
+      body: "Hello world",
+      timestamp: 1_700_000_000_000,
+    });
+    expect(events).toHaveLength(1);
+    const evt = events[0]!;
+    expect(evt.type).toBe("message");
+    const msg = (evt as { type: "message"; data: MessengerMessage }).data;
+    expect(msg.id).toBe("mid.1");
+    expect(msg.text).toBe("Hello world");
+    expect(msg.threadId).toBe("t.1");
+    expect(msg.senderId).toBe("u.1");
+  });
+
+  test("maps reaction event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "message_reaction",
+      messageID: "mid.2",
+      threadID: "t.1",
+      userID: "u.2",
+      reaction: "❤️",
+      timestamp: 1_700_000_001_000,
+    });
+    expect(events[0]!.type).toBe("reaction");
+    const d = (events[0] as Extract<MessengerEvent, { type: "reaction" }>).data;
+    expect(d.reaction).toBe("❤️");
+    expect(d.actorId).toBe("u.2");
+  });
+
+  test("maps typing event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "typ",
+      threadID: "t.1",
+      from: "u.3",
+      isTyping: true,
+    });
+    expect(events[0]!.type).toBe("typing");
+    const d = (events[0] as Extract<MessengerEvent, { type: "typing" }>).data;
+    expect(d.isTyping).toBe(true);
+    expect(d.senderId).toBe("u.3");
+  });
+
+  test("maps unsend event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "message_unsend",
+      messageID: "mid.3",
+      threadID: "t.1",
+      senderID: "u.1",
+      timestamp: 1_700_000_002_000,
+    });
+    expect(events[0]!.type).toBe("message_unsend");
+  });
+
+  test("maps read_receipt event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "read_receipt",
+      threadID: "t.1",
+      reader: "u.4",
+      time: 1_700_000_003_000,
+    });
+    expect(events[0]!.type).toBe("read_receipt");
+    const d = (events[0] as Extract<MessengerEvent, { type: "read_receipt" }>).data;
+    expect(d.readerId).toBe("u.4");
+  });
+
+  test("maps presence event", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "presence",
+      userID: "u.5",
+      userStatus: 1,
+      timestamp: 1_700_000_004_000,
+    });
+    expect(events[0]!.type).toBe("presence");
+    const d = (events[0] as Extract<MessengerEvent, { type: "presence" }>).data;
+    expect(d.userId).toBe("u.5");
+    expect(d.isOnline).toBe(true);
+  });
+
+  test("maps unknown event to raw", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, { type: "some_unknown_type", foo: "bar" });
+    expect(events[0]!.type).toBe("raw");
+  });
+
+  test("maps message with attachments", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "message",
+      messageID: "mid.10",
+      threadID: "t.1",
+      senderID: "u.1",
+      body: "",
+      timestamp: 1_700_000_005_000,
+      attachments: [
+        { type: "photo", url: "https://cdn.fb.com/img.jpg", width: 800, height: 600 },
+      ],
+    });
+    const msg = (events[0] as Extract<MessengerEvent, { type: "message" }>).data;
+    expect(msg.attachments).toHaveLength(1);
+    expect(msg.attachments![0]!.type).toBe("photo");
+  });
+
+  test("maps message with replyTo", () => {
+    const { controller, eventBus } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, {
+      type: "message",
+      messageID: "mid.11",
+      threadID: "t.1",
+      senderID: "u.1",
+      body: "yes",
+      timestamp: 1_700_000_006_000,
+      messageReply: { messageID: "mid.old", senderID: "u.2", body: "original" },
+    });
+    const msg = (events[0] as Extract<MessengerEvent, { type: "message" }>).data;
+    expect(msg.replyTo?.messageId).toBe("mid.old");
+    expect(msg.replyTo?.senderId).toBe("u.2");
+  });
+
+  test("maps e2ee_connected event and marks e2ee service", () => {
+    const { controller, eventBus, e2eeService } = makeServices();
+    const events = collectEvents(controller, eventBus);
+    fireRaw(controller, { type: "e2ee_connected" });
+    expect(events[0]!.type).toBe("e2ee_connected");
+    expect(e2eeService.isConnected).toBe(true);
+  });
+});
+
+// =============================================================================
+// ClientController - requireApi guard
+// =============================================================================
+
+describe("ClientController E2EE-only guard", () => {
+  test("sendMessage rejects non-E2EE thread IDs", async () => {
+    const { controller } = makeServices();
+    await expect(
+      controller.sendMessage({ threadId: "t.1", text: "hi" }),
+    ).rejects.toThrow("sendMessage is E2EE-only");
+  });
+
+  test("sendMessage requires connectE2EE before E2EE sends", async () => {
+    const { controller } = makeServices();
+    await expect(
+      controller.sendMessage({ threadId: "1001.0@msgr", text: "hi" }),
+    ).rejects.toThrow("sendMessage requires an active E2EE connection");
+  });
+});

package/tests/script/echo-e2ee.ts

@@ -0,0 +1,174 @@
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { FBClient } from "../../src/index.ts";
+import type { E2EEMessage, MessengerEvent } from "../../src/models/domain.ts";
+
+const APPSTATE_PATH = join(process.cwd(), "tests/appstate.json");
+const SESSION_PATH = join(process.cwd(), "tests/session.json");
+const DEVICE_PATH = join(process.cwd(), "tests/device.json");
+const ENV_PATH = join(process.cwd(), "tests/.env");
+const DEFAULT_ECHO_CACHE_TTL_MS = 60_000;
+
+function loadEnvFile(filePath: string): void {
+  if (!existsSync(filePath)) return;
+
+  const raw = readFileSync(filePath, "utf8");
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const idx = trimmed.indexOf("=");
+    if (idx <= 0) continue;
+
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    process.env[key] = value;
+  }
+}
+
+function parseMessengerUserId(value: string): string {
+  const userPart = value.split("@")[0] ?? value;
+  const dotIdx = userPart.indexOf(".");
+  const colonIdx = userPart.indexOf(":");
+  const cuts = [dotIdx, colonIdx].filter((idx) => idx >= 0).sort((a, b) => a - b);
+  const end = cuts[0] ?? userPart.length;
+  return userPart.slice(0, end) || value;
+}
+
+function messageKey(msg: E2EEMessage): string {
+  return msg.id || `${msg.chatJid}:${msg.senderJid}:${msg.timestampMs}:${msg.text}`;
+}
+
+function echoSignature(threadId: string, text: string): string {
+  return `${threadId}\u0000${text}`;
+}
+
+function isTextEchoable(msg: E2EEMessage): boolean {
+  return typeof msg.text === "string" && msg.text.trim().length > 0;
+}
+
+async function main() {
+  loadEnvFile(ENV_PATH);
+
+  if (!existsSync(APPSTATE_PATH)) {
+    console.error("echo-e2ee", `Missing appstate file at ${APPSTATE_PATH}`);
+    process.exit(1);
+  }
+
+  console.log("echo-e2ee", "Initializing FBClient...");
+  const client = new FBClient({
+    appStatePath: APPSTATE_PATH,
+    sessionStorePath: SESSION_PATH,
+  });
+
+  let selfUserId = "";
+  const seenMessageIds = new Set<string>();
+  const ownEchoes = new Map<string, number>();
+  const echoPrefix = process.env.ECHO_PREFIX ?? "";
+  const echoCacheTtlMs = Number(process.env.ECHO_CACHE_TTL_MS ?? String(DEFAULT_ECHO_CACHE_TTL_MS));
+
+  const pruneOwnEchoes = () => {
+    const now = Date.now();
+    for (const [key, expiresAt] of ownEchoes) {
+      if (expiresAt <= now) ownEchoes.delete(key);
+    }
+  };
+
+  client.onEvent(async (event: MessengerEvent) => {
+    try {
+      if (event.type === "e2ee_connected") {
+        console.log("echo-e2ee", "E2EE connected. Echo is ready.");
+        return;
+      }
+
+      if (event.type === "error") {
+        console.error("echo-e2ee", "Client error:", event.data.message);
+        return;
+      }
+
+      if (event.type !== "e2ee_message") return;
+
+      pruneOwnEchoes();
+
+      console.log(event);
+      const msg = event.data;
+      const key = messageKey(msg);
+      if (seenMessageIds.has(key)) return;
+      seenMessageIds.add(key);
+
+      if (!isTextEchoable(msg)) {
+        console.log("echo-e2ee", `Skip non-text/empty E2EE message ${msg.id || "<no-id>"}`);
+        return;
+      }
+
+      const threadId = msg.chatJid || msg.threadId;
+      if (!threadId) {
+        console.warn("echo-e2ee", `Skip message ${msg.id || "<no-id>"}: missing thread id`);
+        return;
+      }
+
+      const senderUserId = parseMessengerUserId(msg.senderId || msg.senderJid);
+      const echoText = `${echoPrefix}${msg.text}`;
+      const sig = echoSignature(threadId, msg.text);
+
+      // If our own echo is delivered back to this client, consume it and stop.
+      // This allows echoing messages sent from another device of the same account,
+      // while avoiding infinite echo loops.
+      if (senderUserId === selfUserId && ownEchoes.has(sig)) {
+        ownEchoes.delete(sig);
+        console.log("echo-e2ee", `Skip own echoed message in ${threadId}: "${msg.text}"`);
+        return;
+      }
+
+      console.log("echo-e2ee", `Echo ${msg.id || "<no-id>"} from ${msg.senderJid} to ${threadId}: "${msg.text}"`);
+      await client.sendMessage({ threadId, text: echoText });
+      ownEchoes.set(echoSignature(threadId, echoText), Date.now() + echoCacheTtlMs);
+    } catch (err) {
+      console.error("echo-e2ee", "Echo failed:", err);
+    }
+  });
+
+  try {
+    console.log("echo-e2ee", "Connecting to Messenger...");
+    const { userId } = await client.connect();
+    selfUserId = parseMessengerUserId(userId);
+    console.log("echo-e2ee", `Connected as User ID: ${selfUserId}`);
+
+    const userDevicePath = join(process.cwd(), `device-${selfUserId}.json`);
+    const finalDevicePath = existsSync(userDevicePath) ? userDevicePath : DEVICE_PATH;
+
+    console.log("echo-e2ee", `Connecting E2EE stream using: ${finalDevicePath}`);
+    await client.connectE2EE(finalDevicePath, selfUserId);
+    console.log("echo-e2ee", "E2EE stream active. Waiting for messages...");
+
+    const exitAfterMs = Number(process.env.ECHO_EXIT_AFTER_MS ?? "0");
+    if (exitAfterMs > 0) {
+      setTimeout(() => {
+        console.log("echo-e2ee", `Exit after ${exitAfterMs}ms`);
+        process.exit(0);
+      }, exitAfterMs);
+    }
+
+    const shutdown = async () => {
+      console.log("\necho-e2ee", "Shutting down...");
+      await client.disconnect().catch(() => {});
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (err) {
+    console.error("echo-e2ee", "Startup failed:", err);
+    await client.disconnect().catch(() => {});
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("echo-e2ee", "Fatal:", err);
+  process.exit(1);
+});