credit

.gitignore

@@ -46,3 +46,4 @@ build/
 
 # Private keys (keep in repo but be careful)
 PRIVATE_KEY.pem
+client_secret.json

auth_utils.py

@@ -25,6 +25,11 @@ if SMTP_SERVER == "127.0.0.1" and "gmail.com" in SMTP_USERNAME:
 
 SMTP_SENDER = os.getenv("SMTP_SENDER", SMTP_USERNAME)
 
+from gmail_service import GmailService
+
+# Initialize Gmail Service
+gmail_service = GmailService()
+
 def verify_password(plain_password: str, hashed_password: str) -> bool:
     """
     Verify a password against a hash.
@@ -50,9 +55,16 @@ def generate_secret_key() -> str:
 
 def send_email(to_email: str, subject: str, body: str):
     """
-    Send an email using SMTP (configured for ProtonMail Bridge).
+    Send an email using Gmail API.
     This function is blocking and should be run in a background task.
     """
+    # Try Gmail API first
+    if gmail_service.authenticate():
+        return gmail_service.send_email(to_email, subject, body)
+    
+    logger.warning("Gmail API credentials not found or invalid. Falling back to SMTP (may fail on some platforms).")
+    
+    # Fallback to SMTP (Original Implementation)
     try:
         message = MIMEMultipart()
         message["From"] = SMTP_SENDER
@@ -63,9 +75,6 @@ def send_email(to_email: str, subject: str, body: str):
         
         # Create a secure SSL context
         context = ssl.create_default_context()
-        # Note: ProtonMail Bridge with "change smtp-security" to SSL usually uses self-signed certs or specific setup.
-        # If using localhost, we might need to bypass hostname check or trust the cert.
-        # For now, we'll try standard SSL context. If it fails on localhost self-signed, we might need check_hostname=False.
         context.check_hostname = False
         context.verify_mode = ssl.CERT_NONE
 
@@ -73,7 +82,7 @@ def send_email(to_email: str, subject: str, body: str):
             server.login(SMTP_USERNAME, SMTP_PASSWORD)
             server.sendmail(SMTP_SENDER, to_email, message.as_string())
             
-        logger.info(f"Email sent successfully to {to_email}")
+        logger.info(f"Email sent successfully to {to_email} via SMTP")
         return True
     except Exception as e:
         logger.error(f"Failed to send email to {to_email}: {e}")

get_gmail_token.py

@@ -0,0 +1,43 @@
+import os
+import json
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+# If modifying these scopes, delete the file token.json.
+SCOPES = ['https://www.googleapis.com/auth/gmail.send']
+
+def get_refresh_token():
+    """Shows basic usage of the Gmail API.
+    Lists the user's Gmail labels.
+    """
+    creds = None
+    
+    # Check if client_secret.json exists
+    if not os.path.exists('client_secret.json'):
+        print("Error: 'client_secret.json' not found.")
+        print("Please download your OAuth 2.0 Client ID JSON file from Google Cloud Console,")
+        print("rename it to 'client_secret.json', and place it in this directory.")
+        return
+
+    flow = InstalledAppFlow.from_client_secrets_file(
+        'client_secret.json', SCOPES)
+    
+    # Run the local server flow to get credentials
+    creds = flow.run_local_server(port=0)
+
+    print("\n--- Authentication Successful ---")
+    print("Here are your credentials details. Please add these to your .env file or HF Secrets:\n")
+    
+    # Extract client config to get ID and Secret easily if needed, though they are in the json file
+    with open('client_secret.json', 'r') as f:
+        client_config = json.load(f)
+        installed = client_config.get('installed', client_config.get('web', {}))
+        print(f"GOOGLE_CLIENT_ID={installed.get('client_id')}")
+        print(f"GOOGLE_CLIENT_SECRET={installed.get('client_secret')}")
+
+    print(f"GOOGLE_REFRESH_TOKEN={creds.refresh_token}")
+    print("\n---------------------------------")
+    print("Note: The access token will expire, but the refresh token is long-lived.")
+    print("Use the refresh token in your application to get new access tokens automatically.")
+
+if __name__ == '__main__':
+    get_refresh_token()

gmail_service.py

@@ -0,0 +1,77 @@
+import os
+import base64
+import logging
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+logger = logging.getLogger(__name__)
+
+class GmailService:
+    SCOPES = ['https://www.googleapis.com/auth/gmail.send']
+
+    def __init__(self):
+        self.creds = None
+        self.service = None
+        self.client_id = os.getenv('GOOGLE_CLIENT_ID')
+        self.client_secret = os.getenv('GOOGLE_CLIENT_SECRET')
+        self.refresh_token = os.getenv('GOOGLE_REFRESH_TOKEN')
+        self.sender_email = os.getenv('SMTP_SENDER') or os.getenv('EMAIL_ID')
+
+    def authenticate(self):
+        """Authenticate using the refresh token."""
+        if not all([self.client_id, self.client_secret, self.refresh_token]):
+            logger.error("Missing Google API credentials (CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN)")
+            return False
+
+        try:
+            # Create credentials object from the refresh token
+            self.creds = Credentials(
+                None,  # No access token initially
+                refresh_token=self.refresh_token,
+                token_uri="https://oauth2.googleapis.com/token",
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+                scopes=self.SCOPES
+            )
+            
+            # Refresh the token (get a new access token)
+            if self.creds and self.creds.expired and self.creds.refresh_token:
+                self.creds.refresh(Request())
+                
+            self.service = build('gmail', 'v1', credentials=self.creds)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to authenticate with Gmail API: {e}")
+            return False
+
+    def send_email(self, to_email: str, subject: str, body: str) -> bool:
+        """Send an email using the Gmail API."""
+        if not self.service:
+            if not self.authenticate():
+                return False
+
+        try:
+            message = MIMEMultipart()
+            message['to'] = to_email
+            message['from'] = self.sender_email
+            message['subject'] = subject
+            message.attach(MIMEText(body, 'plain'))
+
+            raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode('utf-8')
+            body = {'raw': raw_message}
+
+            message = (self.service.users().messages().send(userId="me", body=body).execute())
+            logger.info(f"Email sent to {to_email} (Message Id: {message['id']})")
+            return True
+
+        except HttpError as error:
+            logger.error(f"An error occurred sending email to {to_email}: {error}")
+            return False
+        except Exception as e:
+            logger.error(f"Unexpected error sending email: {e}")
+            return False

requirements.txt

@@ -10,3 +10,6 @@ httpx>=0.25.0
 passlib[bcrypt]>=1.7.4
 email-validator>=2.0.0
 python-dotenv>=1.0.0
+google-api-python-client>=2.0.0
+google-auth-oauthlib>=1.0.0
+google-auth-httplib2>=0.1.0

test_gmail_service.py

@@ -0,0 +1,42 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from gmail_service import GmailService
+
+class TestGmailService(unittest.TestCase):
+
+    @patch('gmail_service.build')
+    @patch('gmail_service.Credentials')
+    def test_send_email_success(self, mock_credentials, mock_build):
+        # Mock the service and its methods
+        mock_service = MagicMock()
+        mock_build.return_value = mock_service
+        
+        # Mock the send method
+        mock_messages = mock_service.users.return_value.messages.return_value
+        mock_messages.send.return_value.execute.return_value = {'id': '12345'}
+
+        # Initialize service
+        service = GmailService()
+        service.client_id = "dummy_id"
+        service.client_secret = "dummy_secret"
+        service.refresh_token = "dummy_token"
+        
+        # Test authenticate
+        self.assertTrue(service.authenticate())
+        
+        # Test send_email
+        result = service.send_email("test@example.com", "Test Subject", "Test Body")
+        self.assertTrue(result)
+        
+        # Verify calls
+        mock_messages.send.assert_called_once()
+
+    def test_missing_credentials(self):
+        service = GmailService()
+        # Ensure credentials are None
+        service.client_id = None
+        
+        self.assertFalse(service.authenticate())
+
+if __name__ == '__main__':
+    unittest.main()