@adens/openwa 0.1.0

package/server/services/session-service.js

@@ -0,0 +1,81 @@
+const { prisma } = require("../database/client");
+
+async function retryOnSqliteTimeout(operation) {
+  let lastError = null;
+  for (const delayMs of [0, 100, 250, 500]) {
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    try {
+      return await operation();
+    } catch (error) {
+      if (error?.code !== "P1008") {
+        throw error;
+      }
+
+      lastError = error;
+    }
+  }
+
+  throw lastError;
+}
+
+async function listUserSessions(userId) {
+  return prisma.whatsappSession.findMany({
+    where: { userId },
+    orderBy: { createdAt: "desc" }
+  });
+}
+
+async function createUserSession(userId, { name, phoneNumber }) {
+  if (!name) {
+    throw new Error("Session name is required.");
+  }
+
+  return prisma.whatsappSession.create({
+    data: {
+      userId,
+      name: String(name).trim(),
+      phoneNumber: phoneNumber ? String(phoneNumber).trim() : null,
+      status: "disconnected",
+      transportType: "wwebjs"
+    }
+  });
+}
+
+async function getSessionById(userId, sessionId) {
+  return prisma.whatsappSession.findFirst({
+    where: {
+      id: sessionId,
+      userId
+    }
+  });
+}
+
+async function listReconnectableSessions() {
+  return prisma.whatsappSession.findMany({
+    where: {
+      status: {
+        in: ["ready", "connecting"]
+      }
+    }
+  });
+}
+
+async function touchSessionState(sessionId, data) {
+  return retryOnSqliteTimeout(() =>
+    prisma.whatsappSession.update({
+      where: { id: sessionId },
+      data
+    })
+  );
+}
+
+module.exports = {
+  createUserSession,
+  getSessionById,
+  listReconnectableSessions,
+  listUserSessions,
+  touchSessionState
+};

package/server/socket/register.js

@@ -0,0 +1,127 @@
+const { getUserFromToken } = require("../services/auth-service");
+const chatService = require("../services/chat-service");
+
+function userRoom(userId) {
+  return `user:${userId}`;
+}
+
+function registerSocketHandlers({ io, config, sessionManager }) {
+  io.use(async (socket, next) => {
+    try {
+      const token = socket.handshake.auth?.token;
+      const user = await getUserFromToken(token, config);
+
+      if (!user) {
+        return next(new Error("Unauthorized"));
+      }
+
+      socket.user = user;
+      return next();
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  io.on("connection", (socket) => {
+    socket.join(userRoom(socket.user.id));
+
+    socket.on("send_message", async (payload = {}, ack) => {
+      try {
+        const result = await chatService.createOutgoingMessage({
+          userId: socket.user.id,
+          chatId: payload.chatId,
+          body: payload.body,
+          type: payload.type || "text",
+          mediaFileId: payload.mediaFileId || null,
+          replyToId: payload.replyToId || null
+        });
+
+        io.to(userRoom(socket.user.id)).emit("new_message", result.message);
+        io.to(userRoom(socket.user.id)).emit("contact_list_update", result.chat);
+
+        if (result.message.sessionId) {
+          await sessionManager.sendMessage(result.message.sessionId, {
+            recipient: result.message.receiver,
+            body: result.message.body,
+            mediaFileId: result.message.mediaFileId,
+            mediaPath: result.message.mediaFile?.relativePath || null
+          });
+
+          await chatService.addMessageStatus(result.message.id, "delivered");
+          io.to(userRoom(socket.user.id)).emit("message_status_update", {
+            messageId: result.message.id,
+            status: "delivered"
+          });
+        }
+
+        if (ack) {
+          ack({ ok: true, message: result.message });
+        }
+      } catch (error) {
+        if (ack) {
+          ack({ ok: false, error: error.message });
+        }
+      }
+    });
+
+    socket.on("send_media", async (payload = {}, ack) => {
+      try {
+        const result = await chatService.createOutgoingMessage({
+          userId: socket.user.id,
+          chatId: payload.chatId,
+          body: payload.body,
+          type: payload.type || "document",
+          mediaFileId: payload.mediaFileId,
+          replyToId: payload.replyToId || null
+        });
+
+        io.to(userRoom(socket.user.id)).emit("new_message", result.message);
+        io.to(userRoom(socket.user.id)).emit("contact_list_update", result.chat);
+
+        if (result.message.sessionId) {
+          await sessionManager.sendMessage(result.message.sessionId, {
+            recipient: result.message.receiver,
+            body: result.message.body,
+            mediaFileId: result.message.mediaFileId,
+            mediaPath: result.message.mediaFile?.relativePath || null
+          });
+        }
+
+        if (ack) {
+          ack({ ok: true, message: result.message });
+        }
+      } catch (error) {
+        if (ack) {
+          ack({ ok: false, error: error.message });
+        }
+      }
+    });
+
+    socket.on("typing", (payload = {}) => {
+      io.to(userRoom(socket.user.id)).emit("typing_event", {
+        chatId: payload.chatId,
+        isTyping: Boolean(payload.isTyping),
+        userId: socket.user.id,
+        name: socket.user.name
+      });
+    });
+
+    socket.on("open_chat", async (payload = {}, ack) => {
+      try {
+        await chatService.markChatOpened(socket.user.id, payload.chatId);
+        if (ack) {
+          ack({ ok: true });
+        }
+      } catch (error) {
+        if (ack) {
+          ack({ ok: false, error: error.message });
+        }
+      }
+    });
+  });
+}
+
+module.exports = {
+  registerSocketHandlers,
+  userRoom
+};

package/server/utils/avatar.js

@@ -0,0 +1,34 @@
+function initials(name) {
+  return String(name || "?")
+    .split(" ")
+    .map((part) => part[0])
+    .join("")
+    .slice(0, 2)
+    .toUpperCase();
+}
+
+function colorForSeed(seed) {
+  const palette = [
+    ["#25d366", "#d2f8e9"],
+    ["#00a884", "#dffaf1"],
+    ["#7c4dff", "#efe7ff"],
+    ["#ff8a65", "#ffe8e0"],
+    ["#5c6bc0", "#e7eaff"],
+    ["#26a69a", "#e0f7f4"]
+  ];
+
+  const source = String(seed || "");
+  const index = source.split("").reduce((sum, char) => sum + char.charCodeAt(0), 0) % palette.length;
+  return palette[index];
+}
+
+function createAvatarDataUrl(name, seed = name) {
+  const label = initials(name);
+  const [background, foreground] = colorForSeed(seed);
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="96" height="96" viewBox="0 0 96 96"><rect width="96" height="96" rx="48" fill="${background}"/><text x="48" y="55" text-anchor="middle" font-family="Segoe UI, Arial, sans-serif" font-size="30" font-weight="700" fill="${foreground}">${label}</text></svg>`;
+  return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+}
+
+module.exports = {
+  createAvatarDataUrl
+};

package/server/utils/paths.js

@@ -0,0 +1,29 @@
+const fs = require("fs");
+const path = require("path");
+
+const rootDir = path.resolve(__dirname, "..", "..");
+const storageDir = path.join(rootDir, "storage");
+const sessionsDir = path.join(storageDir, "sessions");
+const mediaDir = path.join(storageDir, "media");
+const databaseDir = path.join(storageDir, "database");
+const prismaSchemaPath = path.join(rootDir, "prisma", "schema.prisma");
+const webDir = path.join(rootDir, "web");
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function ensureRuntimeDirs() {
+  [storageDir, sessionsDir, mediaDir, databaseDir].forEach(ensureDir);
+}
+
+module.exports = {
+  rootDir,
+  storageDir,
+  sessionsDir,
+  mediaDir,
+  databaseDir,
+  prismaSchemaPath,
+  webDir,
+  ensureRuntimeDirs
+};

package/server/whatsapp/adapters/mock-adapter.js

@@ -0,0 +1,47 @@
+const EventEmitter = require("events");
+const QRCode = require("qrcode");
+
+class MockAdapter extends EventEmitter {
+  constructor({ session }) {
+    super();
+    this.session = session;
+    this.connected = false;
+  }
+
+  async connect() {
+    this.emit("status", { status: "connecting", transportType: "mock" });
+    const qrCode = await QRCode.toDataURL(`openwa:${this.session.id}:${Date.now()}`);
+    this.emit("qr", { qrCode, transportType: "mock" });
+
+    setTimeout(() => {
+      this.connected = true;
+      this.emit("status", { status: "ready", transportType: "mock" });
+    }, 1200);
+  }
+
+  async disconnect() {
+    this.connected = false;
+    this.emit("status", { status: "disconnected", transportType: "mock" });
+  }
+
+  async sendMessage(payload) {
+    if (!this.connected) {
+      throw new Error("Mock session is not connected yet.");
+    }
+
+    setTimeout(() => {
+      this.emit("message", {
+        sender: payload.recipient,
+        displayName: this.session.name,
+        body: `Auto reply: ${payload.body || "Media received"}`,
+        type: payload.mediaFileId ? "document" : "text"
+      });
+    }, 1800);
+
+    return {
+      externalMessageId: `mock-${Date.now()}`
+    };
+  }
+}
+
+module.exports = { MockAdapter };

package/server/whatsapp/adapters/wwebjs-adapter.js

@@ -0,0 +1,263 @@
+const EventEmitter = require("events");
+const QRCode = require("qrcode");
+const path = require("path");
+const { sessionsDir, rootDir } = require("../../utils/paths");
+
+class WwebjsAdapter extends EventEmitter {
+  constructor({ session }) {
+    super();
+    this.session = session;
+    this.client = null;
+  }
+
+  async resolveProfilePic(externalId) {
+    if (!this.client || !externalId) {
+      return {
+        url: null,
+        status: "missing",
+        reason: "client-not-ready-or-empty-id"
+      };
+    }
+
+    const result = await this.client.pupPage.evaluate(async (contactId) => {
+      try {
+        const chatWid = window.Store.WidFactory.createWid(contactId);
+        let profilePic = null;
+
+        if (typeof window.Store.ProfilePic.profilePicFind === "function") {
+          profilePic = await window.Store.ProfilePic.profilePicFind(chatWid);
+        }
+
+        if (!profilePic && typeof window.Store.ProfilePic.requestProfilePicFromServer === "function") {
+          profilePic = await window.Store.ProfilePic.requestProfilePicFromServer(chatWid);
+        }
+
+        return profilePic?.eurl || profilePic?.imgFull || profilePic?.img || null;
+      } catch (error) {
+        const message = String(error?.message || error || "");
+        if (message.includes("isNewsletter")) {
+          return {
+            __status: "newsletter-guard"
+          };
+        }
+
+        if (error?.name === "ServerStatusCodeError") {
+          return {
+            __status: "server-status"
+          };
+        }
+
+        return {
+          __error: {
+            name: String(error?.name || "Error"),
+            message
+          }
+        };
+      }
+    }, externalId);
+
+    if (result?.__error) {
+      return {
+        url: null,
+        status: "error",
+        reason: result.__error.message,
+        errorName: result.__error.name
+      };
+    }
+
+    if (result?.__status === "newsletter-guard") {
+      return {
+        url: null,
+        status: "newsletterGuard",
+        reason: "wwebjs-newsletter-guard"
+      };
+    }
+
+    if (result?.__status === "server-status") {
+      return {
+        url: null,
+        status: "serverStatus",
+        reason: "server-status-code-error"
+      };
+    }
+
+    if (!result) {
+      return {
+        url: null,
+        status: "missing",
+        reason: "no-profile-photo-returned"
+      };
+    }
+
+    return {
+      url: result,
+      status: "found",
+      reason: "profile-photo-found"
+    };
+  }
+
+  async resolveProfilePicUrl(externalId) {
+    const result = await this.resolveProfilePic(externalId);
+    if (result.status === "error") {
+      console.warn(`Failed to fetch WhatsApp profile photo for ${externalId}: ${result.reason}`);
+    }
+
+    return result.url;
+  }
+
+  async connect() {
+    const { Client, LocalAuth } = require("whatsapp-web.js");
+
+    this.client = new Client({
+      authStrategy: new LocalAuth({
+        clientId: this.session.id,
+        dataPath: sessionsDir
+      }),
+      puppeteer: {
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      }
+    });
+
+    this.client.on("qr", async (qr) => {
+      const qrCode = await QRCode.toDataURL(qr);
+      this.emit("qr", { qrCode, transportType: "wwebjs" });
+    });
+
+    this.client.on("loading_screen", () => {
+      this.emit("status", { status: "connecting", transportType: "wwebjs" });
+    });
+
+    this.client.on("ready", () => {
+      this.emit("status", { status: "ready", transportType: "wwebjs" });
+    });
+
+    this.client.on("disconnected", (reason) => {
+      this.emit("status", {
+        status: "disconnected",
+        transportType: "wwebjs",
+        lastError: typeof reason === "string" ? reason : "Disconnected"
+      });
+    });
+
+    this.client.on("auth_failure", (message) => {
+      this.emit("status", {
+        status: "error",
+        transportType: "wwebjs",
+        lastError: message
+      });
+    });
+
+    this.client.on("message", (message) => {
+      void (async () => {
+        const chatId = String(message.from || "");
+        const isPrivateChat = chatId.endsWith("@c.us");
+        const isGroupChat = chatId.endsWith("@g.us");
+
+        if (!isPrivateChat && !isGroupChat) {
+          return;
+        }
+
+        this.emit("message", {
+          sender: chatId,
+          displayName: message._data?.notifyName || message._data?.pushname || chatId,
+          avatarUrl: await this.resolveProfilePicUrl(chatId),
+          body: message.body,
+          type: "text"
+        });
+      })().catch((error) => {
+        console.error("Failed to process incoming WhatsApp message.", error);
+      });
+    });
+
+    await this.client.initialize();
+  }
+
+  async disconnect() {
+    if (this.client) {
+      await this.client.destroy();
+      this.client = null;
+    }
+    this.emit("status", { status: "disconnected", transportType: "wwebjs" });
+  }
+
+  async getSyncSnapshot() {
+    if (!this.client) {
+      throw new Error("WhatsApp client is not ready.");
+    }
+
+    const [contacts, chats] = await Promise.all([this.client.getContacts(), this.client.getChats()]);
+    const contactSnapshots = await Promise.all(
+      contacts.map(async (contact) => {
+        const externalId = contact.id?._serialized || "";
+        const avatarResult = await this.resolveProfilePic(externalId);
+
+        return {
+          externalId,
+          name: contact.name || contact.shortName || "",
+          pushname: contact.pushname || contact.name || "",
+          avatarUrl: avatarResult.url
+        };
+      })
+    );
+    const contactAvatarMap = new Map(contactSnapshots.map((contact) => [contact.externalId, contact.avatarUrl]));
+    const chatSnapshots = [];
+
+    for (const chat of chats) {
+      const externalId = chat.id?._serialized || "";
+      if (!externalId.endsWith("@c.us") && !externalId.endsWith("@g.us")) {
+        continue;
+      }
+
+      const messages = await chat.fetchMessages({ limit: 50 });
+      const chatAvatarResult = contactAvatarMap.get(externalId)
+        ? { url: contactAvatarMap.get(externalId), status: "found", reason: "reused-contact-avatar" }
+        : await this.resolveProfilePic(externalId);
+
+      chatSnapshots.push({
+        externalId,
+        name: chat.name || chat.formattedTitle || externalId,
+        pushname: chat.name || chat.formattedTitle || externalId,
+        avatarUrl: chatAvatarResult.url,
+        messages: messages.map((message) => ({
+          externalMessageId: message.id?._serialized || null,
+          sender: message.fromMe ? `user:${this.session.userId}` : message.author || message.from || externalId,
+          body: message.body || null,
+          type: message.type,
+          direction: message.fromMe ? "outbound" : "inbound",
+          ack: message.ack ?? 0,
+          createdAt: new Date((message.timestamp || Math.floor(Date.now() / 1000)) * 1000).toISOString()
+        }))
+      });
+    }
+
+    return {
+      contacts: contactSnapshots,
+      chats: chatSnapshots
+    };
+  }
+
+  async sendMessage(payload) {
+    if (!this.client) {
+      throw new Error("WhatsApp client is not ready.");
+    }
+
+    if (payload.mediaFileId) {
+      const { MessageMedia } = require("whatsapp-web.js");
+      const mediaPath = path.join(rootDir, "storage", payload.mediaPath || "");
+
+      const media = MessageMedia.fromFilePath(mediaPath);
+      const response = await this.client.sendMessage(payload.recipient, media, payload.body ? { caption: payload.body } : undefined);
+      return {
+        externalMessageId: response.id?._serialized || null
+      };
+    }
+
+    const response = await this.client.sendMessage(payload.recipient, payload.body || "");
+    return {
+      externalMessageId: response.id?._serialized || null
+    };
+  }
+}
+
+module.exports = { WwebjsAdapter };