263 lines
9.4 KiB
Python
263 lines
9.4 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Email Poller with WhatsApp Notifications for RAG Integration
|
|
Sends WhatsApp message after successful document upload.
|
|
"""
|
|
|
|
import imaplib
|
|
import email
|
|
import os
|
|
import json
|
|
import time
|
|
import requests
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
# Configuration from environment
|
|
IMAP_HOST = os.environ.get("IMAP_HOST", "mail.oe74.net")
|
|
IMAP_PORT = int(os.environ.get("IMAP_PORT", "993"))
|
|
IMAP_USER = os.environ.get("IMAP_USER")
|
|
IMAP_PASS = os.environ.get("IMAP_PASS")
|
|
RAG_URL = os.environ.get("RAG_URL", "http://moxie-rag:8899")
|
|
RAG_COLLECTION = os.environ.get("RAG_COLLECTION")
|
|
ALLOWED_SENDERS = os.environ.get("ALLOWED_SENDERS", "").split(",")
|
|
STATE_FILE = os.environ.get("STATE_FILE", "/app/data/email_state.json")
|
|
LOG_DIR = os.environ.get("LOG_DIR", "/app/logs")
|
|
NOTIFY_NUMBER = os.environ.get("NOTIFY_NUMBER", "+50660151288") # WhatsApp number to notify
|
|
|
|
def log(msg):
|
|
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
log_msg = f"[{timestamp}] {msg}"
|
|
print(log_msg)
|
|
|
|
log_file = Path(LOG_DIR) / f"{RAG_COLLECTION}_poller.log"
|
|
log_file.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(log_file, "a") as f:
|
|
f.write(log_msg + "\n")
|
|
|
|
def send_whatsapp_notification(filename, sender, collection):
|
|
"""Send WhatsApp notification via OpenClaw gateway"""
|
|
try:
|
|
# Use the OpenClaw gateway to send WhatsApp
|
|
gateway_url = os.environ.get("GATEWAY_URL", "http://host.docker.internal:18789")
|
|
gateway_token = os.environ.get("GATEWAY_TOKEN", "")
|
|
|
|
message = f"📧 *Library Update*\n\n" \
|
|
f"*Document:* `{filename}`\n" \
|
|
f"*From:* {sender}\n" \
|
|
f"*Collection:* {collection}\n" \
|
|
f"*Time:* {datetime.now().strftime('%H:%M:%S')}\n\n" \
|
|
f"Added to your Library successfully ✅"
|
|
|
|
headers = {}
|
|
if gateway_token:
|
|
headers["Authorization"] = f"Bearer {gateway_token}"
|
|
|
|
response = requests.post(
|
|
f"{gateway_url}/message/send",
|
|
headers=headers,
|
|
json={
|
|
"channel": "whatsapp",
|
|
"target": NOTIFY_NUMBER,
|
|
"message": message
|
|
},
|
|
timeout=10
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
log(f"✅ WhatsApp notification sent to {NOTIFY_NUMBER}")
|
|
else:
|
|
log(f"⚠️ WhatsApp notification failed: {response.status_code}")
|
|
|
|
except Exception as e:
|
|
log(f"⚠️ Failed to send WhatsApp: {e}")
|
|
|
|
def load_state():
|
|
try:
|
|
with open(STATE_FILE, "r") as f:
|
|
return set(json.load(f))
|
|
except (FileNotFoundError, json.JSONDecodeError):
|
|
return set()
|
|
|
|
def save_state(processed_ids):
|
|
Path(STATE_FILE).parent.mkdir(parents=True, exist_ok=True)
|
|
with open(STATE_FILE, "w") as f:
|
|
json.dump(list(processed_ids), f)
|
|
|
|
def process_email(imap, msg_id, processed_ids):
|
|
"""Download and process an email"""
|
|
try:
|
|
typ, data = imap.fetch(msg_id, '(RFC822)')
|
|
if not data or not data[0]:
|
|
return False
|
|
|
|
raw_email = data[0][1]
|
|
msg = email.message_from_bytes(raw_email)
|
|
|
|
sender = msg.get('From', '')
|
|
subject = msg.get('Subject', '')
|
|
|
|
log(f"Processing email {msg_id}: {subject[:50]}... from {sender}")
|
|
|
|
# Check allowed senders
|
|
if ALLOWED_SENDERS and ALLOWED_SENDERS[0]:
|
|
allowed = any(a.strip().lower() in sender.lower() for a in ALLOWED_SENDERS)
|
|
if not allowed:
|
|
log(f"Skipping - sender not in allowlist")
|
|
return False
|
|
|
|
# Process attachments
|
|
attachments = []
|
|
if msg.is_multipart():
|
|
for part in msg.walk():
|
|
if part.get_content_maintype() == 'multipart':
|
|
continue
|
|
if part.get('Content-Disposition') is None:
|
|
continue
|
|
|
|
filename = part.get_filename()
|
|
if filename:
|
|
content = part.get_payload(decode=True)
|
|
attachments.append({
|
|
'filename': filename,
|
|
'content': content,
|
|
'type': part.get_content_type()
|
|
})
|
|
log(f"Found attachment: {filename}")
|
|
|
|
# Send to RAG
|
|
uploaded_files = []
|
|
if attachments:
|
|
for att in attachments:
|
|
try:
|
|
files = {'file': (att['filename'], att['content'])}
|
|
data = {'collection': RAG_COLLECTION}
|
|
|
|
response = requests.post(
|
|
f"{RAG_URL}/ingest",
|
|
files=files,
|
|
data=data,
|
|
timeout=60
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
log(f"✅ Uploaded {att['filename']} to {RAG_COLLECTION}")
|
|
uploaded_files.append(att['filename'])
|
|
else:
|
|
log(f"❌ Failed to upload {att['filename']}: {response.status_code}")
|
|
|
|
except Exception as e:
|
|
log(f"❌ Error uploading {att['filename']}: {e}")
|
|
|
|
# Send WhatsApp notification for successful uploads
|
|
if uploaded_files:
|
|
for filename in uploaded_files:
|
|
send_whatsapp_notification(filename, sender, RAG_COLLECTION)
|
|
else:
|
|
# Process email body text
|
|
body = ""
|
|
if msg.is_multipart():
|
|
for part in msg.walk():
|
|
if part.get_content_type() == "text/plain":
|
|
body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
|
|
break
|
|
else:
|
|
body = msg.get_payload(decode=True).decode('utf-8', errors='ignore')
|
|
|
|
if body:
|
|
try:
|
|
response = requests.post(
|
|
f"{RAG_URL}/ingest_text",
|
|
json={
|
|
'collection': RAG_COLLECTION,
|
|
'text': body,
|
|
'metadata': {
|
|
'source': f'email:{sender}',
|
|
'subject': subject,
|
|
'date': msg.get('Date')
|
|
}
|
|
},
|
|
timeout=60
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
log(f"✅ Uploaded email body to {RAG_COLLECTION}")
|
|
send_whatsapp_notification("Email body text", sender, RAG_COLLECTION)
|
|
else:
|
|
log(f"❌ Failed to upload email body: {response.status_code}")
|
|
|
|
except Exception as e:
|
|
log(f"❌ Error uploading email body: {e}")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
log(f"❌ Error processing email {msg_id}: {e}")
|
|
return False
|
|
|
|
def poll_loop():
|
|
"""Main polling loop"""
|
|
processed_ids = load_state()
|
|
poll_interval = int(os.environ.get("POLL_INTERVAL", "300"))
|
|
reconnect_delay = 5
|
|
|
|
while True:
|
|
try:
|
|
log(f"Connecting to {IMAP_HOST}:{IMAP_PORT}...")
|
|
imap = imaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT)
|
|
|
|
log(f"Logging in as {IMAP_USER}...")
|
|
imap.login(IMAP_USER, IMAP_PASS)
|
|
|
|
imap.select('INBOX')
|
|
log(f"Polling every {poll_interval} seconds...")
|
|
reconnect_delay = 5
|
|
|
|
while True:
|
|
# Search for unseen messages
|
|
typ, data = imap.search(None, 'UNSEEN')
|
|
|
|
if data[0]:
|
|
msg_ids = data[0].decode().split()
|
|
log(f"Found {len(msg_ids)} new messages")
|
|
|
|
for msg_id in msg_ids:
|
|
if msg_id not in processed_ids:
|
|
if process_email(imap, msg_id, processed_ids):
|
|
processed_ids.add(msg_id)
|
|
save_state(processed_ids)
|
|
else:
|
|
log(f"Skipping already processed message {msg_id}")
|
|
|
|
# Wait before next poll
|
|
time.sleep(poll_interval)
|
|
|
|
# Keep connection alive
|
|
imap.noop()
|
|
|
|
except KeyboardInterrupt:
|
|
log("Interrupted by user - exiting")
|
|
break
|
|
except Exception as e:
|
|
log(f"❌ Connection error: {e}")
|
|
log(f"Reconnecting in {reconnect_delay} seconds...")
|
|
time.sleep(reconnect_delay)
|
|
reconnect_delay = min(reconnect_delay * 2, 300)
|
|
|
|
if __name__ == "__main__":
|
|
if not IMAP_USER or not IMAP_PASS:
|
|
log("❌ Error: IMAP_USER and IMAP_PASS required")
|
|
exit(1)
|
|
|
|
if not RAG_COLLECTION:
|
|
log("❌ Error: RAG_COLLECTION required")
|
|
exit(1)
|
|
|
|
log("=" * 60)
|
|
log(f"Email Poller with WhatsApp notifications starting")
|
|
log(f"Collection: {RAG_COLLECTION}")
|
|
log(f"Notify: {NOTIFY_NUMBER}")
|
|
log("=" * 60)
|
|
|
|
poll_loop()
|