Update app.py

app.py

@@ -4,123 +4,36 @@ import smtplib
 import re
 from email.mime.text import MIMEText
 from flask import Flask, request, jsonify
-from aiosmtpd.controller import Controller
-from aiosmtpd.handlers import Sink
-from aiosmtpd.smtp import SMTP, AuthResult, LoginPassword
 from dotenv import load_dotenv
 import os
-import threading
-from typing import Optional
 
 # Load environment variables
 load_dotenv()
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("app")
+logger = logging.getLogger("bot_brain")
 
 # SMTP Server Configuration
 SMTP_HOST = os.getenv("SMTP_HOST", "0.0.0.0")
 SMTP_PORT = int(os.getenv("SMTP_PORT", "587"))
 CLIENT_SMTP_HOST = os.getenv("CLIENT_SMTP_HOST", "localhost")
-CLIENT_SMTP_PORT = SMTP_PORT
 SMTP_USER = os.getenv("SMTP_USER", "noreply@yourdomain.com")
 SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "password")
 
-# WhatsApp webhook configuration
-WHATSAPP_WEBHOOK_TOKEN = os.getenv("WHATSAPP_WEBHOOK_TOKEN", "my_secure_accesstoken123")
-WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_phone_number_id")
-META_ACCESS_TOKEN = os.getenv("META_ACCESS_TOKEN", "default_meta_access_token")
-
-# Global conversation state mapping sender's WhatsApp number to their conversation details.
+# Global conversation state: maps sender's WhatsApp number to conversation data.
 conversations = {}
 
-# Authentication Credentials for SMTP server
-VALID_USERS = {
-    SMTP_USER: SMTP_PASSWORD,
-}
-
-# Flask app for WhatsApp bot
-app = Flask(__name__)
-
-# Regular expression for validating email addresses
+# Regex for validating email addresses
 EMAIL_REGEX = re.compile(r"^[^@]+@[^@]+\.[^@]+$")
 
 def validate_email(email: str) -> bool:
-    """Simple email validation using a regex."""
     return re.match(EMAIL_REGEX, email) is not None
 
-class AuthenticatedSMTPHandler(Sink):
-    """
-    Custom SMTP handler that logs incoming emails and enforces simple LOGIN authentication.
-    """
-    async def handle_AUTH(self, server: SMTP, args: str, mechanism: str) -> Optional[AuthResult]:
-        if mechanism.upper() != "LOGIN":
-            return AuthResult(success=False, handled=False)
-        return None
-
-    async def handle_AUTH_LOGIN(self, server: SMTP, args: str) -> Optional[AuthResult]:
-        try:
-            parts = args.split()
-            if len(parts) != 2:
-                return AuthResult(success=False, message="Invalid authentication format")
-            username, password = parts
-            if username in VALID_USERS and VALID_USERS[username] == password:
-                logger.info(f"Authenticated user: {username}")
-                return AuthResult(success=True, auth_data=LoginPassword(username, password))
-            else:
-                logger.warning(f"Authentication failed for user: {username}")
-                return AuthResult(success=False, message="Invalid credentials")
-        except Exception as e:
-            logger.error(f"Authentication error: {e}")
-            return AuthResult(success=False, message="Authentication failed")
-
-    async def handle_DATA(self, server: SMTP, session, envelope):
-        try:
-            message_content = envelope.content.decode('utf-8', errors='replace')
-            logger.info(f"Received email from: {envelope.mail_from}")
-            logger.info(f"Recipients: {envelope.rcpt_tos}")
-            logger.info(f"Message data:\n{message_content}")
-            return "250 Message accepted for delivery"
-        except Exception as e:
-            logger.error(f"Error processing email data: {e}")
-            return "451 Internal server error"
-
-def start_smtp_server() -> Controller:
-    """
-    Starts the SMTP server with SSL/TLS and authentication.
-    """
-    try:
-        ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        ssl_context.load_cert_chain("cert.pem", "key.pem")
-        logger.info("SSL context created successfully.")
-    except Exception as e:
-        logger.error(f"Failed to load SSL certificate and key: {e}")
-        raise
-
-    handler = AuthenticatedSMTPHandler()
-    controller = Controller(
-        handler,
-        hostname=SMTP_HOST,
-        port=SMTP_PORT,
-        enable_SMTPUTF8=True,
-        ssl_context=ssl_context,
-        auth_required=True,
-    )
-
-    try:
-        logger.info(f"Starting SMTP server on {SMTP_HOST}:{SMTP_PORT} with SSL/TLS...")
-        controller.start()
-    except Exception as e:
-        logger.error(f"Failed to start SMTP server: {e}")
-        raise
-
-    return controller
-
 def send_email(from_addr: str, to_addr: str, subject: str, body: str) -> bool:
     """
-    Sends an email using the SMTP client. The 'from_addr' is provided by the user.
-    Note: Some SMTP servers restrict the 'From' address to the authenticated user.
+    Sends an email using the SMTP client.
+    Note: Some SMTP servers restrict the 'From' address.
     """
     msg = MIMEText(body)
     msg['Subject'] = subject
@@ -128,7 +41,7 @@ def send_email(from_addr: str, to_addr: str, subject: str, body: str) -> bool:
     msg['To'] = to_addr
 
     try:
-        with smtplib.SMTP(CLIENT_SMTP_HOST, CLIENT_SMTP_PORT) as server:
+        with smtplib.SMTP(CLIENT_SMTP_HOST, SMTP_PORT) as server:
             server.starttls()  # Upgrade to TLS
             server.login(SMTP_USER, SMTP_PASSWORD)
             server.sendmail(from_addr, [to_addr], msg.as_string())
@@ -138,113 +51,72 @@ def send_email(from_addr: str, to_addr: str, subject: str, body: str) -> bool:
         logger.error(f"Error sending email from {from_addr} to {to_addr}: {e}")
         return False
 
-@app.route("/webhook", methods=["GET", "POST"])
-def webhook():
+# Flask app acting as the Bot Brain API
+app = Flask(__name__)
+
+@app.route("/bot", methods=["POST"])
+def bot():
     """
-    Handles WhatsApp webhook verification and processes incoming messages.
-    This bot acts as an SMTP assistant guiding the user to provide:
-      1. 'From' email address
-      2. Recipient ('To') email address
-      3. Email subject
-      4. Email body
-    Once all details are provided, the email is sent.
+    Receives a message from the Node.js server.
+    The bot implements a conversation flow:
+      1. Ask for the 'From' email address.
+      2. Ask for the recipient ('To') email address.
+      3. Ask for the email subject.
+      4. Ask for the email body.
+    When all details are collected, the email is sent.
     """
-    if request.method == "GET":
-        mode = request.args.get("hub.mode")
-        token = request.args.get("hub.verify_token")
-        challenge = request.args.get("hub.challenge")
-
-        if mode == "subscribe" and token == WHATSAPP_WEBHOOK_TOKEN:
-            logger.info("Webhook verified successfully.")
-            return challenge, 200
-        else:
-            logger.error("Webhook verification failed.")
-            return "Verification failed", 403
-
-    elif request.method == "POST":
-        try:
-            data = request.json
-            logger.info(f"Incoming webhook data: {data}")
-            value = data["entry"][0]["changes"][0]["value"]
-            message = value["messages"][0]
-            sender_number = message.get("from", "unknown")
-            phone_number_id = value.get("metadata", {}).get("phone_number_id", WHATSAPP_PHONE_NUMBER_ID)
-            message_body = message.get("text", {}).get("body", "").strip()
-        except Exception as e:
-            logger.error(f"Error parsing webhook data: {e}")
-            return jsonify({"status": "error", "message": "Invalid webhook payload"}), 400
-
-        # Retrieve or initialize the conversation state for this sender.
-        state = conversations.get(sender_number, {})
-
-        # If no conversation exists, start a new one.
-        if not state:
-            conversations[sender_number] = {"step": "from"}
-            response_msg = "Welcome to SMTP Assistant! Please provide your 'From' email address."
-        else:
-            step = state.get("step")
-            if step == "from":
-                if validate_email(message_body):
-                    state["from"] = message_body
-                    state["step"] = "to"
-                    response_msg = "Thanks! Now, please provide the recipient's email address."
-                else:
-                    response_msg = "Invalid email format. Please provide a valid 'From' email address."
-            elif step == "to":
-                if validate_email(message_body):
-                    state["to"] = message_body
-                    state["step"] = "subject"
-                    response_msg = "Great! Please provide the email subject."
-                else:
-                    response_msg = "Invalid email format. Please provide a valid recipient email address."
-            elif step == "subject":
-                state["subject"] = message_body
-                state["step"] = "body"
-                response_msg = "Almost done! Please provide the email body."
-            elif step == "body":
-                state["body"] = message_body
-                # All details collected; send the email.
-                from_addr = state.get("from")
-                to_addr = state.get("to")
-                subject = state.get("subject")
-                body = state.get("body")
-                if send_email(from_addr, to_addr, subject, body):
-                    response_msg = f"Email sent successfully from {from_addr} to {to_addr}."
-                else:
-                    response_msg = "Failed to send email. Please try again later."
-                # Clear conversation state.
-                del conversations[sender_number]
-            else:
-                response_msg = "Unrecognized step. Let's start over. Please provide your 'From' email address."
-                conversations[sender_number] = {"step": "from"}
-
-        # Optionally, if you wish to send a follow-up message via the WhatsApp Business API,
-        # you can use META_ACCESS_TOKEN in the HTTP request headers.
-        return jsonify({"status": "success", "message": response_msg}), 200
-
-def run_flask_app():
     try:
-        app.run(host="0.0.0.0", port=5000)
+        data = request.json
+        sender_number = data.get("from", "unknown")
+        # Use the message body from WhatsApp (trim any extra spaces)
+        message_body = data.get("text", {}).get("body", "").strip()
     except Exception as e:
-        logger.error(f"Error starting Flask app: {e}")
-
-def main():
-    try:
-        smtp_controller = start_smtp_server()
-    except Exception as e:
-        logger.critical("Failed to start SMTP server. Exiting.")
-        return
-
-    flask_thread = threading.Thread(target=run_flask_app)
-    flask_thread.start()
+        logger.error("Invalid JSON payload: %s", e)
+        return jsonify({"status": "error", "message": "Invalid payload"}), 400
+
+    state = conversations.get(sender_number, {})
+
+    if not state:
+        # Start a new conversation
+        conversations[sender_number] = {"step": "from"}
+        response_msg = "Welcome to SMTP Assistant! Please provide your 'From' email address."
+    else:
+        step = state.get("step")
+        if step == "from":
+            if validate_email(message_body):
+                state["from"] = message_body
+                state["step"] = "to"
+                response_msg = "Thanks! Now, please provide the recipient's email address."
+            else:
+                response_msg = "Invalid email format. Please provide a valid 'From' email address."
+        elif step == "to":
+            if validate_email(message_body):
+                state["to"] = message_body
+                state["step"] = "subject"
+                response_msg = "Great! Please provide the email subject."
+            else:
+                response_msg = "Invalid email format. Please provide a valid recipient email address."
+        elif step == "subject":
+            state["subject"] = message_body
+            state["step"] = "body"
+            response_msg = "Almost done! Please provide the email body."
+        elif step == "body":
+            state["body"] = message_body
+            from_addr = state.get("from")
+            to_addr = state.get("to")
+            subject = state.get("subject")
+            body = state.get("body")
+            if send_email(from_addr, to_addr, subject, body):
+                response_msg = f"Email sent successfully from {from_addr} to {to_addr}."
+            else:
+                response_msg = "Failed to send email. Please try again later."
+            # Clear the conversation state after sending
+            del conversations[sender_number]
+        else:
+            response_msg = "Unrecognized step. Let's start over. Please provide your 'From' email address."
+            conversations[sender_number] = {"step": "from"}
 
-    try:
-        flask_thread.join()
-    except KeyboardInterrupt:
-        logger.info("Keyboard interrupt received. Shutting down servers...")
-    finally:
-        smtp_controller.stop()
-        logger.info("SMTP server stopped.")
+    return jsonify({"status": "success", "message": response_msg})
 
 if __name__ == "__main__":
-    main()
+    app.run(host="0.0.0.0", port=5000)