Create server.js

server.js

@@ -0,0 +1,289 @@
+const fs = require("fs");
+const express = require("express");
+const { makeWASocket, fetchLatestBaileysVersion, useMultiFileAuthState, makeInMemoryStore } = require("@whiskeysockets/baileys");
+const http = require("http");
+const socketIo = require("socket.io");
+const bodyParser = require("body-parser");
+const path = require("path");
+
+const app = express();
+const server = http.createServer(app);
+const io = socketIo(server);
+const PORT = process.env.PORT || 7860;
+
+const store = makeInMemoryStore({});
+
+// Paths
+const MESSAGES_FILE = "./messages.json";
+const SESSION_DIR = "./session"; // Directory to store session credentials
+
+// Initialize Express
+// Middleware
+app.use(express.static("public"));
+app.use(bodyParser.json());
+
+// Load or initialize `messages.json`
+if (!fs.existsSync(MESSAGES_FILE)) fs.writeFileSync(MESSAGES_FILE, JSON.stringify([]));
+const loadMessages = () => JSON.parse(fs.readFileSync(MESSAGES_FILE));
+const saveMessages = (messages) => fs.writeFileSync(MESSAGES_FILE, JSON.stringify(messages));
+
+// Initialize Baileys with saved session keys
+const initBaileys = async () => {
+    const { version } = await fetchLatestBaileysVersion();
+    const { state, saveCreds } = await useMultiFileAuthState(SESSION_DIR);
+
+    const socket = makeWASocket({
+        auth: state,
+        version,
+    });
+    
+    store.bind(socket.ev);
+    
+    // Function to get the name for a chat
+    const getChatName = async (jid) => {
+    if (jid.endsWith("@g.us")) {
+        // Fetch group metadata for group chats
+        try {
+            const metadata = await whatsappSocket.groupMetadata(jid);
+            return metadata.subject || "Unknown Group";
+        } catch (err) {
+            console.error("Error fetching group metadata:", err);
+            return "Unknown Group";
+        }
+    } else {
+        // Use contact name for personal chats
+        const contact = store.contacts[jid]; // Fetch from store
+        return contact?.name || contact?.notify || jid; // Fallback to JID if name is not available
+    }
+};
+
+    // Listen for new messages
+    socket.ev.on("messages.upsert", async ({ messages }) => {
+    const allMessages = loadMessages();
+
+    for (const msg of messages) {
+        if (msg.message) {
+            // Extract message content
+            let content = "[Unsupported Message Type]";
+            
+            // Handle different message types
+            if (msg.message.conversation) {
+                content = msg.message.conversation;
+            } else if (msg.message.extendedTextMessage) {
+                content = msg.message.extendedTextMessage.text;
+            } else if (msg.message.imageMessage) {
+                content = msg.message.imageMessage.caption || "[Image]";
+            } else if (msg.message.videoMessage) {
+                content = msg.message.videoMessage.caption || "[Video]";
+            } else if (msg.message.stickerMessage) {
+                content = "[Sticker]";
+            } else if (msg.message.documentMessage) {
+                content = msg.message.documentMessage.fileName || "[Document]";
+            } else if (msg.message.audioMessage) {
+                content = "[Audio]";
+            } else if (msg.message.contactMessage) {
+                content = `[Contact: ${msg.message.contactMessage.displayName || "Unknown"}]`;
+            } else if (msg.message.locationMessage) {
+                const { degreesLatitude, degreesLongitude } = msg.message.locationMessage;
+                content = `[Location: ${degreesLatitude}, ${degreesLongitude}]`;
+            } else if (msg.message.buttonsMessage) {
+                content = msg.message.buttonsMessage.contentText || "[Buttons Message]";
+            } else if (msg.message.listMessage) {
+                content = msg.message.listMessage.description || "[List Message]";
+            } else if (msg.message.pollCreationMessage) {
+                content = msg.message.pollCreationMessage.name || "[Poll]";
+            }
+
+            // Fetch the chat name
+            const chatName = await getChatName(msg.key.remoteJid);
+
+            // Format the message data
+            const messageData = {
+                jid: msg.key.remoteJid,
+                sender: msg.key.fromMe ? "You" : msg.pushName || msg.key.remoteJid,
+                chatName,
+                content,
+                timestamp: msg.messageTimestamp,
+            };
+
+            // Save to messages.json
+            allMessages.push(messageData);
+            saveMessages(allMessages);
+
+            // Emit the message to the frontend via WebSocket
+            io.emit("new_message", messageData);
+        }
+    }
+});
+
+    // Save credentials on update
+    socket.ev.on("connection.update", (update) => {
+        const { connection, lastDisconnect } = update;
+
+        if (connection === "open") {
+            console.log("WhatsApp connected!");
+        } else if (connection === "close") {
+            console.error("Connection closed:", lastDisconnect?.error);
+        }
+    });
+
+    // Save credentials on update
+    socket.ev.on("creds.update", saveCreds);
+
+    return socket;
+};
+
+// Initialize Baileys socket
+let whatsappSocket;
+initBaileys()
+    .then((sock) => {
+        whatsappSocket = sock;
+        console.log("Connected to WhatsApp");
+    })
+    .catch((err) => console.error("Failed to initialize Baileys:", err));
+
+// Routes
+app.get("/", (req, res) => {
+    res.sendFile(path.join(__dirname, "public", "index.html"));
+});
+
+app.get("/chat/:jid", (req, res) => {
+    res.sendFile(path.join(__dirname, "public", "chat.html"));
+});
+
+app.get("/api/messages", async (req, res) => {
+    const allMessages = loadMessages();
+    const uniqueChatsMap = new Map(); // To track unique chats with their data
+
+    for (const msg of allMessages) {
+        // Check if the chat is already processed
+        const existingChat = uniqueChatsMap.get(msg.jid);
+        if (existingChat) {
+            // Update the last message if the timestamp is newer
+            if (msg.timestamp > existingChat.timestamp) {
+                existingChat.lastMessage = msg.content;
+                existingChat.timestamp = msg.timestamp;
+            }
+        } else {
+            // Fetch chat name dynamically
+            try {
+                const chatName = await getChatName(msg.jid);
+                uniqueChatsMap.set(msg.jid, {
+                    jid: msg.jid,
+                    chatName,
+                    lastMessage: msg.content,
+                    timestamp: msg.timestamp,
+                });
+            } catch (error) {
+                console.error(`Failed to fetch chat name for ${msg.jid}:`, error);
+            }
+        }
+    }
+
+    // Convert Map to array and sort by timestamp
+    const uniqueChats = Array.from(uniqueChatsMap.values());
+    uniqueChats.sort((a, b) => b.timestamp - a.timestamp);
+
+    res.json(uniqueChats);
+});
+
+app.get("/messages.json", (req, res) => {
+    res.sendFile(path.join(__dirname, "messages.json"));
+});
+
+app.get("/api/messages/:jid", (req, res) => {
+    const { jid } = req.params;
+    const chatMessages = loadMessages().filter((msg) => msg.jid === jid);
+    res.json(chatMessages);
+});
+
+// WebSocket Connection
+io.on("connection", (socket) => {
+    console.log("Client connected via WebSocket");
+    socket.on("disconnect", () => {
+        console.log("Client disconnected");
+    });
+});
+
+app.post("/send-message", async (req, res) => {
+    const { jid, message, replyTo } = req.body;
+    try {
+        if (whatsappSocket) {
+            if (replyTo) {
+                const messages = loadMessages();
+                const replyMessage = messages.find((msg) => msg.jid === jid && msg.timestamp === replyTo);
+
+                if (replyMessage) {
+                    await whatsappSocket.sendMessage(jid, {
+                        text: message,
+                        quoted: {
+                            key: { remoteJid: jid, id: replyTo },
+                            message: { conversation: replyMessage.content },
+                        },
+                    });
+                }
+            } else {
+                await whatsappSocket.sendMessage(jid, { text: message });
+            }
+            res.sendStatus(200);
+        } else {
+            res.sendStatus(500);
+        }
+    } catch (error) {
+        console.error("Error sending message:", error);
+        res.sendStatus(500);
+    }
+});
+
+app.post("/send-sticker", async (req, res) => {
+    const { jid, stickerPath } = req.body;
+    try {
+        if (whatsappSocket && fs.existsSync(stickerPath)) {
+            await whatsappSocket.sendMessage(jid, { sticker: { url: stickerPath } });
+            res.sendStatus(200);
+        } else {
+            res.status(400).send("Sticker file not found or session not initialized.");
+        }
+    } catch (error) {
+        console.error("Error sending sticker:", error);
+        res.sendStatus(500);
+    }
+});
+
+app.post("/send-image", async (req, res) => {
+    const { jid, imagePath, caption } = req.body;
+    try {
+        if (whatsappSocket && fs.existsSync(imagePath)) {
+            await whatsappSocket.sendMessage(jid, {
+                image: { url: imagePath },
+                caption: caption || "",
+            });
+            res.sendStatus(200);
+        } else {
+            res.status(400).send("Image file not found or session not initialized.");
+        }
+    } catch (error) {
+        console.error("Error sending image:", error);
+        res.sendStatus(500);
+    }
+});
+
+// WebSocket connection
+io.on('connection', (socket) => {
+    console.log('User connected');
+
+    // Example event to listen for new messages
+    socket.on('sendMessage', (message) => {
+        saveMessage(message); // Save the message to storage
+
+        // Broadcast to all connected clients
+        io.emit('newMessage', message);
+    });
+
+    socket.on('disconnect', () => {
+        console.log('User disconnected');
+    });
+});
+
+// Start server
+server.listen(PORT, () => console.log(`Server running on http://localhost:${PORT}`));