Upload 13 files

.env

@@ -0,0 +1,7 @@
+# .env
+MONGODB_URI=mongodb+srv://loda:[email protected]/?retryWrites=true&w=majority&appName=userdata
+# List Admin JIDs separated by commas ONLY (no spaces around commas)
+[email protected],[email protected],[email protected]
+LOG_LEVEL=info # Optional: set to 'debug' for more verbose logs, 'info' for standard
+
+

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "whatsapp-baileys-bot",
+  "version": "1.0.0",
+  "description": "WhatsApp bot using Baileys library",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.7.16",
+    "dotenv": "^16.4.7",
+    "mongodb": "^6.15.0",
+    "mongoose": "^8.13.2",
+    "pino": "^8.21.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "pino-pretty": "^13.0.0"
+  }
+}

src/config.js

@@ -0,0 +1,22 @@
+// src/config.js
+require('dotenv').config();
+
+const adminJidsString = process.env.ADMIN_JIDS || '';
+const adminJids = adminJidsString.split(',')
+                     .map(jid => jid.trim())
+                     .filter(jid => jid);
+
+module.exports = {
+    mongodbUri: process.env.MONGODB_URI,
+    logLevel: process.env.LOG_LEVEL || 'info',
+    adminJids: adminJids, // Exported as an array
+    // Default delays (can be overridden)
+    defaultMinDelay: 500,
+    defaultMaxDelay: 1500,
+    // Specific Delays
+    registrationMinDelay: 2000,
+    registrationMaxDelay: 3000,
+    attendanceMinDelay: 10000,
+    attendanceMaxDelay: 15000,
+};
+

src/connection.js

@@ -0,0 +1,110 @@
+// src/connection.js
+const makeWASocket = require('@whiskeysockets/baileys').default;
+const { DisconnectReason, useMultiFileAuthState, fetchLatestBaileysVersion } = require('@whiskeysockets/baileys');
+const logger = require('./logger');
+const config = require('./config'); // Import config but botJid setting/clearing removed
+const whatsapp = require('./services/whatsappService'); // Import service
+const { processMessage } = require('./handlers/messageHandler'); // Import main handler
+const path = require('path'); // Path is still needed for useMultiFileAuthState path construction
+
+/**
+ * Establishes the WhatsApp connection using Baileys, initializes services,
+ * and sets up event listeners. Filters groups and channels. (Original Refactored Version)
+ */
+async function connectWhatsApp() {
+    // Define auth folder path relative to src/ directory
+    const authFolderPath = path.join(__dirname, '..', 'auth');
+    const { state, saveCreds } = await useMultiFileAuthState(authFolderPath);
+    const { version } = await fetchLatestBaileysVersion();
+
+    logger.info(`Using Baileys version: ${version.join('.')}`);
+
+    const sock = makeWASocket({
+        printQRInTerminal: true,
+        auth: state,
+        version: version,
+        // getMessage: async key => { }, // Define if using message store features
+        logger // Pass pino logger to Baileys
+    });
+
+    // Initialize WhatsApp Service with sock instance
+    whatsapp.initialize(sock);
+
+    // Baileys Event Processing
+    sock.ev.process(async (events) => {
+
+        // ** Connection Logic **
+        if (events['connection.update']) {
+            // (Connection logic remains the same as previous - without auto-delete/auto-restart)
+            const { connection, lastDisconnect, qr } = events['connection.update'];
+            const statusCode = (lastDisconnect?.error)?.output?.statusCode;
+
+            if (connection === 'close') {
+                config.botJid = null; // Clear bot JID on close
+                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+                logger.warn({ err: lastDisconnect?.error, shouldReconnect }, `Connection closed. Status Code: ${statusCode}`);
+                if (shouldReconnect) {
+                    logger.info("Attempting to reconnect in 5 seconds...");
+                    setTimeout(connectWhatsApp, 5000);
+                } else {
+                    logger.error('Connection closed: Logged Out or Invalid Session. Please delete "auth" folder manually and restart.');
+                    process.exit(1);
+                }
+            } else if (connection === 'open') {
+                config.botJid = sock.user?.id;
+                logger.info({ botJid: config.botJid }, 'WhatsApp connection opened and service initialized.');
+                whatsapp.initialize(sock); // Re-initialize service if needed
+            }
+             if(qr) {
+                 logger.info('QR code received, scan please!');
+             }
+        }
+
+        // ** Credentials Update **
+        if (events['creds.update']) {
+            await saveCreds();
+        }
+
+        // ** Message Handling **
+        if (events['messages.upsert']) {
+            const upsert = events['messages.upsert'];
+            // logger.trace({ upsert }, 'Received messages.upsert event');
+
+            if (upsert.type === 'notify') {
+                for (const msg of upsert.messages) {
+                    // --- Basic Message Filtering ---
+                    // Ignore messages without content, from self, or status broadcasts
+                    if (!msg.message || msg.key.fromMe || msg.key.remoteJid === 'status@broadcast') {
+                        // logger.trace({ msgId: msg.key.id }, 'Ignoring message (no content, fromMe, or status broadcast)');
+                        continue;
+                    }
+                    // Ignore group messages
+                    if (msg.key.remoteJid.endsWith('@g.us')) {
+                        // logger.trace({ msgId: msg.key.id, group: msg.key.remoteJid }, 'Ignoring group message');
+                        continue;
+                    }
+                    // *** ADDED: Ignore channel messages ***
+                    if (msg.key.remoteJid.endsWith('@newsletter')) {
+                        logger.trace({ msgId: msg.key.id, channel: msg.key.remoteJid }, 'Ignoring channel message');
+                        continue;
+                    }
+                    // *** END ADDED FILTER ***
+
+                    // Delegate processing asynchronously for valid user messages
+                    setImmediate(() => {
+                         processMessage(msg).catch(err => {
+                            logger.error({ err, msgId: msg?.key?.id }, "Error caught in setImmediate for processMessage");
+                         });
+                    });
+
+                } // end for loop
+            } // end if notify
+        } // end messages.upsert
+
+    }); // End sock.ev.process
+
+    return sock;
+} // End connectWhatsApp
+
+module.exports = { connectWhatsApp };
+

src/database.js

@@ -0,0 +1,38 @@
+// src/database.js
+const mongoose = require('mongoose');
+const logger = require('./logger');
+const config = require('./config');
+
+if (!config.mongodbUri) {
+    logger.fatal("FATAL: MONGODB_URI not found in environment variables/config. Check .env file.");
+    process.exit(1);
+}
+
+// Schema remains the same
+const userSchema = new mongoose.Schema({
+    remoteJid: { type: String, required: true, unique: true },
+    name: { type: String },
+    regNo: { type: String },
+    semester: { type: String },
+    isRegistered: { type: Boolean, default: false },
+    registrationTimestamp: { type: Date }
+});
+
+// Comment on Data Size
+// Data per user is small (~<1KB). 2000 users (~2MB) is well within Atlas free tier limits.
+
+const User = mongoose.model('User', userSchema);
+
+async function connectDB() {
+    try {
+        await mongoose.connect(config.mongodbUri);
+        logger.info('Successfully connected to MongoDB!');
+    } catch (error) {
+        logger.fatal({ err: error }, 'Error connecting to MongoDB');
+        process.exit(1);
+    }
+}
+
+// Export model directly for handlers to import
+module.exports = { connectDB, User };
+

src/handlers/adminHandler.js

@@ -0,0 +1,111 @@
+// src/handlers/adminHandler.js
+const logger = require('../logger');
+const whatsapp = require('../services/whatsappService');
+const { User } = require('../database');
+const config = require('../config');
+
+// State to track pending admin actions requiring confirmation
+// Key: adminJid, Value: { action: 'confirm_clear', semester: '...', timeoutId: ... }
+const adminState = {};
+const CONFIRMATION_TIMEOUT = 60000; // 60 seconds
+
+/**
+ * Clears the pending state for an admin.
+ * @param {string} jid - Admin JID.
+ */
+function clearAdminState(jid) {
+    if (adminState[jid]) {
+        clearTimeout(adminState[jid].timeoutId); // Clear the timeout
+        delete adminState[jid];
+        logger.info({ adminJid: jid }, `[AdminHandler] Cleared pending admin state.`);
+    }
+}
+
+/**
+ * Handles commands sent by recognized admins, including confirmation steps.
+ * Returns true if an admin command (or confirmation) was processed, false otherwise.
+ */
+async function handleAdminCommand(jid, messageContent) {
+    logger.debug({ adminJid: jid, command: messageContent }, `[AdminHandler] Processing potential admin command.`);
+
+    const pendingAction = adminState[jid];
+
+    // --- Step 1: Check if awaiting confirmation ---
+    if (pendingAction) {
+        const confirmation = messageContent.trim().toLowerCase();
+        const semesterToDelete = pendingAction.semester; // Get semester from stored state
+
+        if (pendingAction.action === 'confirm_clear') {
+            if (confirmation === 'yes') {
+                logger.warn({ adminJid: jid, semester: semesterToDelete }, `[AdminHandler] Confirmation 'yes' received for .clear`);
+                clearAdminState(jid); // Clear state before performing action
+                try {
+                    const deleteResult = await User.deleteMany({
+                        semester: { $regex: new RegExp(`^${semesterToDelete}$`, 'i') }
+                    });
+                    const replyText = `✅ Admin: Successfully deleted ${deleteResult.deletedCount} records matching semester "${semesterToDelete}".`;
+                    logger.warn({ result: deleteResult, semester: semesterToDelete }, `[AdminHandler] .clear command executed successfully.`);
+                    await whatsapp.sendMessageWithTyping(jid, { text: replyText });
+                } catch (cmdError) {
+                    logger.error({ err: cmdError, semester: semesterToDelete }, `[AdminHandler] .clear command failed during execution.`);
+                    await whatsapp.sendMessageWithTyping(jid, { text: `❌ Admin: Error executing .clear command for semester "${semesterToDelete}" after confirmation. Check logs.` });
+                }
+            } else { // Includes 'no' or any other reply
+                logger.info({ adminJid: jid, semester: pendingAction.semester, reply: confirmation }, `[AdminHandler] .clear command aborted by admin or invalid confirmation.`);
+                clearAdminState(jid);
+                await whatsapp.sendMessageWithTyping(jid, { text: `❌ Admin: Aborted deletion for semester "${semesterToDelete}".` });
+            }
+        } else {
+            // Handle other potential pending actions here if added later
+            logger.warn({ adminJid: jid, pendingAction }, `[AdminHandler] Unknown pending action found.`);
+            clearAdminState(jid); // Clear unknown state
+        }
+        return true; // Confirmation message was processed
+    }
+
+    // --- Step 2: Check for new commands if not awaiting confirmation ---
+
+    // ** .clear command **
+    if (messageContent.startsWith('.clear ')) {
+        const parts = messageContent.split(' ');
+        if (parts.length === 2 && parts[1]) {
+            const semesterToDelete = parts[1].trim();
+            logger.warn({ adminJid: jid, semester: semesterToDelete }, `[AdminHandler] .clear command received. Requesting confirmation.`);
+
+            // Set pending state with timeout
+            adminState[jid] = {
+                action: 'confirm_clear',
+                semester: semesterToDelete,
+                timeoutId: setTimeout(() => {
+                    if (adminState[jid]?.action === 'confirm_clear') { // Check if still pending this action
+                         logger.warn({ adminJid: jid, semester: semesterToDelete }, `[AdminHandler] Confirmation for .clear timed out.`);
+                         delete adminState[jid]; // Clear state on timeout
+                         whatsapp.sendMessageWithTyping(jid, { text: `⏰ Admin: Confirmation request for deleting semester "${semesterToDelete}" timed out.` }).catch(err => logger.error({err}, "Failed to send timeout message"));
+                    }
+                }, CONFIRMATION_TIMEOUT)
+            };
+
+            // Ask for confirmation
+            const promptText = `❓ *Confirmation Needed* ❓\n\nAre you sure you want to delete ALL student data for semester *${semesterToDelete}*? This cannot be undone.\n\nReply with *Yes* or *No*. (Expires in 60 seconds)`;
+            await whatsapp.sendMessageWithTyping(jid, { text: promptText });
+
+        } else { // Invalid format
+            await whatsapp.sendMessageWithTyping(jid, { text: `❌ Admin: Invalid .clear command format. Use: \`.clear <semester>\` (e.g., \`.clear 3rd\`)` });
+        }
+        return true; // .clear command attempt was handled
+    }
+
+    // --- Add other admin commands here ---
+    // else if (messageContent.startsWith('.some_other_command')) {
+    //    logger.info({ adminJid: jid }, `[AdminHandler] Handling other admin command.`);
+    //    ... handle command ...
+    //    return true;
+    // }
+
+    // If no known admin command matched
+    logger.debug({ adminJid: jid, command: messageContent }, `[AdminHandler] Not a recognized admin command.`);
+    return false; // No admin command was processed
+}
+
+module.exports = { handleAdminCommand };
+

src/handlers/messageHandler.js

@@ -0,0 +1,75 @@
+// src/handlers/messageHandler.js
+const logger = require('../logger');
+const config = require('../config');
+const whatsapp = require('../services/whatsappService');
+const { User } = require('../database');
+const { handleAdminCommand } = require('./adminHandler');
+const { handleRegistration } = require('./registrationHandler');
+const { handleRegisteredUser } = require('./registeredUserHandler');
+
+/**
+ * Processes an incoming message, filters, marks as read (non-blocking),
+ * and routes to the appropriate handler.
+ * @param {object} msg - The Baileys message object.
+ */
+async function processMessage(msg) {
+    // Define jid early for potential use in top-level catch
+    const jid = msg?.key?.remoteJid || 'unknown';
+    try {
+        const messageContent = msg.message?.conversation || msg.message?.extendedTextMessage?.text || '';
+
+        // Ignore empty text messages
+        if (!messageContent.trim() && !msg.message?.buttonsResponseMessage) {
+             logger.trace({ jid }, "[MessageHandler] Ignoring empty message content.");
+             return;
+        }
+
+        // --- Mark as Read (Fire-and-Forget) ---
+        // Call readReceipt WITHOUT 'await'. This lets the function run
+        // in the background without blocking further execution.
+        // If it times out, it will log a warning (due to the try/catch
+        // inside whatsappService.readReceipt) but won't crash the app here.
+        whatsapp.readReceipt([msg.key]);
+        // --- End Mark as Read ---
+
+        // --- Routing ---
+        logger.info({ jid, msg: messageContent }, `[MessageHandler] Processing received message`);
+
+        // 1. Check if Admin Command
+        if (config.adminJids.length > 0 && config.adminJids.includes(jid)) {
+            const commandHandled = await handleAdminCommand(jid, messageContent);
+            if (commandHandled) {
+                logger.info({ jid, msg: messageContent }, `[MessageHandler] Admin command handled.`);
+                return; // Stop processing
+            }
+            logger.debug({ jid }, "[MessageHandler] Message from admin JID not a known admin command, proceeding.");
+        }
+
+        // 2. Check DB for User Status
+        let dbUser = await User.findOne({ remoteJid: jid });
+
+        // 3. Route to appropriate handler
+        if (dbUser && dbUser.isRegistered) {
+            logger.debug({ jid }, "[MessageHandler] Routing to RegisteredUserHandler.");
+            await handleRegisteredUser(jid, messageContent, dbUser);
+        } else {
+            logger.debug({ jid }, "[MessageHandler] Routing to RegistrationHandler.");
+            await handleRegistration(jid, messageContent);
+        }
+
+    } catch (error) {
+        // Catch errors from DB check or handler execution
+        logger.error({ jid, err: error }, `[MessageHandler] Error processing message`);
+        try {
+            // Use default delay for error message
+            if (jid !== 'unknown') {
+                await whatsapp.sendMessageWithTyping(jid, { text: "Sorry, an internal error occurred. Please try again." });
+            }
+        } catch (sendError) {
+            logger.error({ jid, err: sendError }, `[MessageHandler] CRITICAL: Failed to send error notification`);
+        }
+    }
+}
+
+module.exports = { processMessage };
+

src/handlers/registeredUserHandler.js

@@ -0,0 +1,37 @@
+// src/handlers/registeredUserHandler.js
+const logger = require('../logger');
+const whatsapp = require('../services/whatsappService');
+const config = require('../config'); // Import config for delays
+
+/**
+ * Handles incoming messages from already registered users. Uses whatsappService.
+ */
+async function handleRegisteredUser(jid, messageContent, dbUser) {
+    logger.debug({ jid, name: dbUser.name, msg: messageContent }, `[RegisteredUserHandler] Handling message.`);
+
+    const trimmedLowerCaseMsg = messageContent.trim().toLowerCase();
+
+    // 1. Check for "attendance" keyword
+    if (trimmedLowerCaseMsg.includes('attendance')) {
+        logger.info({ jid, name: dbUser.name }, `[RegisteredUserHandler] Attendance keyword detected.`);
+        // Use specific attendance delay
+        const delayOptions = { minDelay: config.attendanceMinDelay, maxDelay: config.attendanceMaxDelay };
+        await whatsapp.sendMessageWithTyping(jid, { text: `Okay ${dbUser.name}, preparing your attendance details... (PDF generation coming soon!)` }, delayOptions);
+        return;
+    }
+
+    // 2. Check for exact "hi" or "hello"
+    if (trimmedLowerCaseMsg === 'hi' || trimmedLowerCaseMsg === 'hello') {
+        logger.info({ jid, name: dbUser.name }, `[RegisteredUserHandler] Greeting triggered.`);
+        // Use default delay for greeting
+        await whatsapp.sendMessageWithTyping(jid, { text: `Hello ${dbUser.name}! You are already registered.` });
+        return;
+    }
+
+    // No action/reply for other messages
+    logger.debug({ jid, name: dbUser.name, msg: messageContent }, `[RegisteredUserHandler] No specific action triggered. No reply sent.`);
+
+}
+
+module.exports = { handleRegisteredUser };
+

src/handlers/registrationHandler.js

@@ -0,0 +1,131 @@
+// src/handlers/registrationHandler.js (previously selfReg.js)
+const logger = require('../logger');
+const whatsapp = require('../services/whatsappService');
+const { User } = require('../database'); // Import User model directly
+const config = require('../config'); // Import config for delays
+const { sleep } = require('../utils'); // Import sleep directly if needed
+
+const userState = {};
+const REGISTRATION_DELAY_MIN = 2000; // 2 seconds
+const REGISTRATION_DELAY_MAX = 3000; // 3 seconds
+
+/**
+ * Handles the multi-step registration process. Uses whatsappService for communication.
+ * /restart command functionality has been removed.
+ */
+async function handleRegistration(jid, messageContent) { // Renamed remoteJid to jid for consistency
+    logger.debug({ jid }, `[RegistrationHandler] Handling step.`);
+
+    const currentState = userState[jid] || { step: 'START', data: {} };
+    const delayOptions = { minDelay: config.registrationMinDelay, maxDelay: config.registrationMaxDelay };
+
+    // REMOVED: Global /restart check is removed from here.
+
+    try { // Wrap steps in try-catch
+        switch (currentState.step) {
+            case 'START':
+                userState[jid] = { step: 'ASKING_NAME', data: {} };
+                // REMOVED: Mention of /restart removed from the prompt
+                await whatsapp.sendMessageWithTyping(jid, { text: "Hi there! Let's get you registered.\n\nWhat is your full Name?" }, delayOptions);
+                break;
+
+            case 'ASKING_NAME':
+                if (!messageContent.trim()) {
+                    await whatsapp.sendMessageWithTyping(jid, { text: "Please enter a valid name." }, delayOptions);
+                    break;
+                }
+                currentState.data.name = messageContent.trim();
+                currentState.step = 'ASKING_REGNO';
+                userState[jid] = currentState;
+                logger.debug({ jid, data: currentState.data }, `[RegistrationHandler] Name received.`);
+                await whatsapp.sendMessageWithTyping(jid, { text: `Got it, ${currentState.data.name}.\n\nWhat is your Registration Number?` }, delayOptions);
+                break;
+
+            case 'ASKING_REGNO':
+                 if (!messageContent.trim()) {
+                    await whatsapp.sendMessageWithTyping(jid, { text: "Please enter a valid registration number." }, delayOptions);
+                    break;
+                }
+                currentState.data.regNo = messageContent.trim();
+                currentState.step = 'ASKING_SEMESTER';
+                userState[jid] = currentState;
+                logger.debug({ jid, data: currentState.data }, `[RegistrationHandler] RegNo received.`);
+                await whatsapp.sendMessageWithTyping(jid, { text: "Great!\n\nWhich Semester are you in? (e.g., 1st, 2nd, 3rd, 4th)" }, delayOptions);
+                break;
+
+            case 'ASKING_SEMESTER':
+                 if (!messageContent.trim()) {
+                    await whatsapp.sendMessageWithTyping(jid, { text: "Please enter a valid semester." }, delayOptions);
+                    break;
+                }
+                currentState.data.semester = messageContent.trim();
+                currentState.step = 'CONFIRMING';
+                userState[jid] = currentState;
+                logger.debug({ jid, data: currentState.data }, `[RegistrationHandler] Semester received.`);
+
+                const confirmationText = `?? *Please confirm your details:* ??\n\n*Name:* ${currentState.data.name}\n*Reg No:* ${currentState.data.regNo}\n*Semester:* ${currentState.data.semester}\n\nIs this correct? Reply with *yes* or *no*.`;
+                await whatsapp.sendMessageWithTyping(jid, { text: confirmationText }, delayOptions);
+                break;
+
+            case 'CONFIRMING':
+                const confirmation = messageContent.trim().toLowerCase();
+                if (confirmation === 'yes') {
+                    try {
+                        logger.info({ jid, data: currentState.data }, `[RegistrationHandler] User confirmed. Saving data.`);
+                        await sleep(300); // Small pause before DB write
+
+                        const updateResult = await User.updateOne(
+                            { remoteJid: jid },
+                            {
+                                $set: {
+                                    name: currentState.data.name,
+                                    regNo: currentState.data.regNo,
+                                    semester: currentState.data.semester,
+                                    isRegistered: true,
+                                    registrationTimestamp: new Date()
+                                }
+                            },
+                            { upsert: true }
+                        );
+                        logger.info({ jid, result: updateResult }, `[RegistrationHandler] MongoDB update result.`);
+
+                        if (updateResult.acknowledged) {
+                             await whatsapp.sendMessageWithTyping(jid, { text: "✅ Registration successful! Your details have been saved." }, delayOptions);
+                             delete userState[jid]; // Clear state
+                        } else { throw new Error("Database update not acknowledged."); }
+                    } catch (dbError) {
+                        logger.error({ jid, err: dbError }, `[RegistrationHandler] Error saving data during confirmation.`);
+                        // REMOVED: Mention of /restart in error message
+                        await whatsapp.sendMessageWithTyping(jid, { text: "❌ Sorry, there was an error saving your details. Please reply 'yes' again or 'no' to start over." }, delayOptions);
+                    }
+                } else if (confirmation === 'no') { // Only 'no' triggers restart now
+                    logger.info({ jid }, `[RegistrationHandler] User replied 'no' at confirmation.`);
+                    delete userState[jid];
+                    userState[jid] = { step: 'ASKING_NAME', data: {} };
+                    await whatsapp.sendMessageWithTyping(jid, { text: "Okay, let's start over.\n\nWhat is your full Name?" }, delayOptions);
+                } else {
+                    await whatsapp.sendMessageWithTyping(jid, { text: "Please reply with *yes* or *no*." }, delayOptions);
+                }
+                break;
+
+            default: // Unhandled state
+                logger.warn({ jid, state: currentState.step }, `[RegistrationHandler] Unhandled state step.`);
+                 delete userState[jid];
+                 await whatsapp.sendMessageWithTyping(jid, { text: "Something went wrong during registration. Please send any message to try starting again." }, delayOptions); // Updated generic error
+                break;
+        }
+    } catch (stepError) { // Catch errors in the switch/case logic itself
+         logger.error({ jid, err: stepError, step: currentState.step }, "[RegistrationHandler] Error during registration step execution.");
+         try {
+            // REMOVED: Mention of /restart in generic error message
+            await whatsapp.sendMessageWithTyping(jid, { text: "An unexpected error occurred during registration. Please try starting again by sending any message." });
+            delete userState[jid]; // Reset state on error
+         } catch (sendErr) {
+             logger.error({ jid, err: sendErr }, "[RegistrationHandler] Failed to send error message during step error handling.");
+         }
+    }
+}
+
+module.exports = { handleRegistration };
+
+

src/index.js

@@ -0,0 +1,44 @@
+// src/index.js - Main Entry Point
+require('dotenv').config(); // Ensure env variables are loaded first
+
+const logger = require('./logger');
+const { connectDB } = require('./database');
+const { connectWhatsApp } = require('./connection');
+
+/**
+ * Starts the application by connecting to the database
+ * and then establishing the WhatsApp connection.
+ */
+async function start() {
+    logger.info("===================================");
+    logger.info("      Starting WhatsApp Bot        ");
+    logger.info("===================================");
+    try {
+        await connectDB();
+        await connectWhatsApp();
+    } catch (error) {
+        logger.fatal({ err: error }, "Critical error during application startup sequence.");
+        process.exit(1); // Exit if essential connections fail
+    }
+}
+
+// Execute startup sequence
+start().catch(err => {
+    // This catch is unlikely to be hit if errors in start() are handled
+    // but provides a final safety net.
+    logger.fatal({ err: err }, "FATAL UNHANDLED ERROR during startup!");
+    process.exit(1);
+});
+
+// Optional: Graceful shutdown handling
+process.on('SIGINT', () => {
+    logger.warn("Received SIGINT. Shutting down gracefully...");
+    // Add cleanup logic here if needed (e.g., close DB connection)
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.warn("Received SIGTERM. Shutting down gracefully...");
+    // Add cleanup logic here
+    process.exit(0);
+});
+

src/logger.js

@@ -0,0 +1,12 @@
+// src/logger.js
+const pino = require('pino');
+const config = require('./config');
+
+const logger = pino({
+  level: config.logLevel,
+  // Pino automatically handles pretty printing if pino-pretty is installed
+  // and output is piped to it (node src/index.js | pino-pretty)
+});
+
+module.exports = logger;
+

src/services/whatsappService.js

@@ -0,0 +1,93 @@
+// src/services/whatsappService.js
+const { randomDelay, sleep } = require('../utils');
+const logger = require('../logger');
+const config = require('../config');
+
+let sockInstance = null;
+
+/**
+ * Initializes the WhatsApp Service with the Baileys socket instance.
+ * Should be called once after connection is established.
+ * @param {object} sock - The Baileys socket instance.
+ */
+function initialize(sock) {
+    if (!sockInstance) {
+        sockInstance = sock;
+        logger.info('WhatsApp Service Initialized.');
+    }
+}
+
+/**
+ * Sends a presence update (typing, paused, available, unavailable).
+ * @param {'composing' | 'paused' | 'available' | 'unavailable'} status - The presence status.
+ * @param {string} jid - The target JID.
+ */
+async function sendPresenceUpdate(status, jid) {
+    if (!sockInstance) return logger.error('WhatsApp Service not initialized for sendPresenceUpdate');
+    try {
+        await sockInstance.sendPresenceUpdate(status, jid);
+    } catch (err) {
+        logger.error({ err, jid, status }, '[WhatsAppService] Failed to send presence update');
+    }
+}
+
+/**
+ * Marks specific messages as read.
+ * @param {Array<object>} keys - An array of message key objects.
+ */
+async function readReceipt(keys) {
+     if (!sockInstance) return logger.error('WhatsApp Service not initialized for readReceipt');
+     try {
+        await sockInstance.readMessages(keys);
+        // Log the first key for brevity if needed
+        if (keys && keys[0]) {
+            logger.debug({ jid: keys[0].remoteJid, msgId: keys[0].id }, `[WhatsAppService] Marked message(s) as read`);
+        }
+     } catch (err) {
+        const jid = keys && keys[0] ? keys[0].remoteJid : 'unknown';
+        logger.warn({ err, jid }, '[WhatsAppService] Failed to mark message(s) as read');
+     }
+}
+
+/**
+ * Sends a message with simulated typing and random delay.
+ * @param {string} jid - The target JID.
+ * @param {object} message - The Baileys message object (e.g., { text: 'Hello' }).
+ * @param {object} [options={}] - Options object.
+ * @param {number} [options.minDelay] - Minimum delay (defaults to config.defaultMinDelay).
+ * @param {number} [options.maxDelay] - Maximum delay (defaults to config.defaultMaxDelay).
+ * @returns {Promise<object|null>} - The result from Baileys sendMessage or null on init error.
+ */
+async function sendMessageWithTyping(jid, message, options = {}) {
+    if (!sockInstance) {
+        logger.error({ jid, message }, 'WhatsApp Service not initialized for sendMessage');
+        return null; // Indicate failure
+    }
+
+    // Use provided delays or fall back to config defaults
+    const minDelayMs = options.minDelay ?? config.defaultMinDelay;
+    const maxDelayMs = options.maxDelay ?? config.defaultMaxDelay;
+
+    try {
+        await sendPresenceUpdate('composing', jid);
+        await randomDelay(minDelayMs, maxDelayMs);
+        await sendPresenceUpdate('paused', jid); // Clear composing state before sending
+
+        const result = await sockInstance.sendMessage(jid, message);
+        logger.debug({ jid, msgContent: message.text || '[Non-Text]' }, '[WhatsAppService] Message sent');
+        return result;
+    } catch (err) {
+        logger.error({ err, jid, msgContent: message.text || '[Non-Text]' }, '[WhatsAppService] Failed to send message');
+        // Re-throw error for the calling handler to potentially manage
+        // Avoid sending another message from here to prevent loops
+        throw err;
+    }
+}
+
+module.exports = {
+    initialize,
+    sendMessageWithTyping,
+    readReceipt,
+    // Only export specific actions needed by handlers
+};
+

src/utils.js

@@ -0,0 +1,32 @@
+// src/utils.js
+
+/**
+ * Creates a promise that resolves after a specified number of milliseconds.
+ * @param {number} ms - The number of milliseconds to sleep.
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Waits for a random amount of time within a specified range.
+ * Uses defaults from config if no arguments provided.
+ * @param {number} [minMs] - Minimum delay in milliseconds.
+ * @param {number} [maxMs] - Maximum delay in milliseconds.
+ * @returns {Promise<void>}
+ */
+ // Import config inside if needed for defaults, or keep simple defaults here
+ const config = require('./config'); // Import config to use defaults
+
+async function randomDelay(minMs = config.defaultMinDelay, maxMs = config.defaultMaxDelay) {
+    // Ensure min is not greater than max
+    if (minMs > maxMs) {
+        [minMs, maxMs] = [maxMs, minMs]; // Swap if necessary
+    }
+    const delay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    await sleep(delay);
+}
+
+module.exports = { randomDelay, sleep };
+