Claude
eba450c5a5
fetch_unread_messages now returns both `body` (stripped, for the LLM) and `raw_body` (full with nested quotes, for the outgoing reply). main.py passes raw_body as quoted_text so each reply carries the complete conversation thread, not just the single last message. https://claude.ai/code/session_01HaUFs7SaLD5SoiuGCY27Tw
308 lines
10 KiB
Python
308 lines
10 KiB
Python
"""IMAP / SMTP email channel adapter.
|
|
|
|
Handles:
|
|
- Polling the inbox for unread messages (IMAP)
|
|
- Conversation matching by sender email address (NOT by thread headers)
|
|
- Sending reply emails (SMTP) with proper threading headers for email clients
|
|
- Stripping quoted reply text so the agent only sees the new content
|
|
|
|
Threading headers (Message-ID, In-Reply-To, References) are preserved for
|
|
outbound replies so messages appear threaded in Gmail/Outlook, but they are
|
|
NOT used to identify which conversation an incoming message belongs to.
|
|
Conversation matching is exclusively by normalized sender email address.
|
|
"""
|
|
|
|
import email
|
|
import email.header
|
|
import email.utils
|
|
import imaplib
|
|
import logging
|
|
import re
|
|
import smtplib
|
|
import time
|
|
from email.mime.multipart import MIMEMultipart
|
|
from email.mime.text import MIMEText
|
|
from typing import Optional
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _decode_header(value: str) -> str:
|
|
"""Decode an RFC-2047 encoded email header value."""
|
|
parts = email.header.decode_header(value or "")
|
|
decoded = []
|
|
for part, charset in parts:
|
|
if isinstance(part, bytes):
|
|
decoded.append(part.decode(charset or "utf-8", errors="replace"))
|
|
else:
|
|
decoded.append(part)
|
|
return "".join(decoded)
|
|
|
|
|
|
def _extract_text(msg: email.message.Message) -> str:
|
|
"""Extract the plain-text body from a (potentially multi-part) message."""
|
|
if msg.is_multipart():
|
|
for part in msg.walk():
|
|
if (
|
|
part.get_content_type() == "text/plain"
|
|
and "attachment" not in str(part.get("Content-Disposition", ""))
|
|
):
|
|
charset = part.get_content_charset() or "utf-8"
|
|
payload = part.get_payload(decode=True)
|
|
if payload:
|
|
return payload.decode(charset, errors="replace")
|
|
else:
|
|
charset = msg.get_content_charset() or "utf-8"
|
|
payload = msg.get_payload(decode=True)
|
|
if payload:
|
|
return payload.decode(charset, errors="replace")
|
|
return ""
|
|
|
|
|
|
def _strip_quoted_text(text: str) -> str:
|
|
"""Remove quoted reply text from the email body.
|
|
|
|
Heuristics:
|
|
- Drop lines starting with ">"
|
|
- Stop at common reply-separator patterns
|
|
"""
|
|
lines = text.splitlines()
|
|
result: list[str] = []
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
if stripped.startswith(">"):
|
|
continue
|
|
# Common separators used by email clients
|
|
if re.match(r"^-{3,}|^_{3,}|^={3,}", stripped):
|
|
break
|
|
if re.match(r"^On .+ wrote:$", stripped):
|
|
break
|
|
if re.match(r"^Am .+ schrieb .+:$", stripped): # German Outlook/Thunderbird
|
|
break
|
|
if "-----Original Message-----" in stripped:
|
|
break
|
|
result.append(line)
|
|
return "\n".join(result).strip()
|
|
|
|
|
|
def _generate_message_id(from_addr: str) -> str:
|
|
domain = from_addr.split("@")[-1] if "@" in from_addr else "meister-eder.local"
|
|
return f"<{time.time():.6f}.{id(from_addr)}@{domain}>"
|
|
|
|
|
|
def _build_quoted_block(original_text: str, from_addr: str) -> str:
|
|
"""Format original_text as a standard email quote block.
|
|
|
|
Produces the classic:
|
|
|
|
On <date>, <from> wrote:
|
|
> line 1
|
|
> line 2
|
|
"""
|
|
date_str = time.strftime("%a, %d %b %Y %H:%M", time.localtime())
|
|
header = f"Am {date_str} schrieb {from_addr}:"
|
|
quoted_lines = "\n".join(
|
|
f"> {line}" for line in original_text.splitlines()
|
|
)
|
|
return f"\n\n{header}\n{quoted_lines}"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Main class
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class EmailChannel:
|
|
"""Wraps IMAP polling and SMTP sending for the email conversation channel."""
|
|
|
|
def __init__(
|
|
self,
|
|
imap_host: str,
|
|
imap_port: int,
|
|
smtp_host: str,
|
|
smtp_port: int,
|
|
username: str,
|
|
password: str,
|
|
use_ssl: bool = True,
|
|
use_tls: bool = True,
|
|
registration_email: str = "",
|
|
) -> None:
|
|
self._imap_host = imap_host
|
|
self._imap_port = imap_port
|
|
self._smtp_host = smtp_host
|
|
self._smtp_port = smtp_port
|
|
self._username = username
|
|
self._password = password
|
|
self._use_ssl = use_ssl
|
|
self._use_tls = use_tls
|
|
self._from_email = registration_email or username
|
|
|
|
# ------------------------------------------------------------------
|
|
# IMAP — receive
|
|
# ------------------------------------------------------------------
|
|
|
|
def fetch_unread_messages(self) -> list[dict]:
|
|
"""Poll the inbox and return all unread messages as structured dicts.
|
|
|
|
Each dict contains:
|
|
from — sender email address (use this as conversation key)
|
|
subject — decoded subject line
|
|
message_id — Message-ID of this inbound email (for reply threading)
|
|
in_reply_to — In-Reply-To header (for reply threading, may be empty)
|
|
references — References header (for reply threading, may be empty)
|
|
body — stripped plain-text body (quoted text removed)
|
|
|
|
Note: ``thread_id`` is no longer returned. Conversation matching is done
|
|
by ``from`` (sender email address), not by threading headers.
|
|
"""
|
|
messages: list[dict] = []
|
|
try:
|
|
imap = self._connect_imap()
|
|
imap.select("INBOX")
|
|
|
|
_, data = imap.search(None, "UNSEEN")
|
|
msg_nums = data[0].split()
|
|
|
|
for num in msg_nums:
|
|
try:
|
|
_, raw_data = imap.fetch(num, "(RFC822)")
|
|
raw = raw_data[0][1]
|
|
msg = email.message_from_bytes(raw)
|
|
|
|
from_addr = email.utils.parseaddr(msg.get("From", ""))[1]
|
|
subject = _decode_header(msg.get("Subject", "(no subject)"))
|
|
message_id = msg.get("Message-ID", "").strip()
|
|
in_reply_to = msg.get("In-Reply-To", "").strip()
|
|
references = msg.get("References", "").strip()
|
|
|
|
raw_body = _extract_text(msg)
|
|
body = _strip_quoted_text(raw_body)
|
|
|
|
if not body.strip():
|
|
imap.store(num, "+FLAGS", "\\Seen")
|
|
continue
|
|
|
|
messages.append(
|
|
{
|
|
"from": from_addr,
|
|
"subject": subject,
|
|
"message_id": message_id,
|
|
"in_reply_to": in_reply_to,
|
|
"references": references,
|
|
"body": body,
|
|
"raw_body": raw_body,
|
|
}
|
|
)
|
|
imap.store(num, "+FLAGS", "\\Seen")
|
|
|
|
except Exception:
|
|
logger.exception("Error processing IMAP message %s", num)
|
|
|
|
imap.logout()
|
|
|
|
except Exception:
|
|
logger.exception("IMAP connection/fetch error")
|
|
|
|
return messages
|
|
|
|
# ------------------------------------------------------------------
|
|
# SMTP — send
|
|
# ------------------------------------------------------------------
|
|
|
|
def send_reply(
|
|
self,
|
|
to: str,
|
|
subject: str,
|
|
body: str,
|
|
in_reply_to: str = "",
|
|
references: str = "",
|
|
quoted_text: str = "",
|
|
quoted_from: str = "",
|
|
) -> str:
|
|
"""Send an email reply.
|
|
|
|
If quoted_text is provided it is appended to body as a standard
|
|
``> ``-prefixed quote block so parents can see what they wrote.
|
|
|
|
Returns the new Message-ID so the caller can track the thread.
|
|
"""
|
|
new_message_id = _generate_message_id(self._from_email)
|
|
|
|
# Ensure subject starts with "Re:"
|
|
if not subject.lower().startswith("re:"):
|
|
subject = f"Re: {subject}"
|
|
|
|
# Build References chain
|
|
ref_parts = [r for r in [references, in_reply_to] if r]
|
|
new_references = " ".join(ref_parts)
|
|
|
|
# Append quoted original message
|
|
if quoted_text.strip():
|
|
body = body + _build_quoted_block(quoted_text, quoted_from or to)
|
|
|
|
msg = MIMEMultipart("alternative")
|
|
msg["From"] = self._from_email
|
|
msg["To"] = to
|
|
msg["Subject"] = subject
|
|
msg["Message-ID"] = new_message_id
|
|
if in_reply_to:
|
|
msg["In-Reply-To"] = in_reply_to
|
|
if new_references:
|
|
msg["References"] = new_references
|
|
|
|
msg.attach(MIMEText(body, "plain", "utf-8"))
|
|
|
|
if not self._smtp_host:
|
|
logger.warning("SMTP not configured — reply NOT sent to %s: %s", to, subject)
|
|
logger.debug("Reply body:\n%s", body)
|
|
return new_message_id
|
|
|
|
try:
|
|
if self._use_tls:
|
|
server = smtplib.SMTP(self._smtp_host, self._smtp_port)
|
|
server.starttls()
|
|
else:
|
|
server = smtplib.SMTP_SSL(self._smtp_host, self._smtp_port)
|
|
|
|
server.login(self._username, self._password)
|
|
server.sendmail(self._from_email, [to], msg.as_string())
|
|
server.quit()
|
|
logger.info("Reply sent to %s (thread %s)", to, in_reply_to or new_message_id)
|
|
except Exception:
|
|
logger.exception("Failed to send reply to %s", to)
|
|
|
|
return new_message_id
|
|
|
|
def send_reminder(
|
|
self,
|
|
to: str,
|
|
subject: str,
|
|
body: str,
|
|
in_reply_to: str = "",
|
|
references: str = "",
|
|
) -> None:
|
|
"""Send a reminder email for an incomplete registration."""
|
|
self.send_reply(
|
|
to=to,
|
|
subject=subject,
|
|
body=body,
|
|
in_reply_to=in_reply_to,
|
|
references=references,
|
|
)
|
|
|
|
# ------------------------------------------------------------------
|
|
# Internal helpers
|
|
# ------------------------------------------------------------------
|
|
|
|
def _connect_imap(self) -> imaplib.IMAP4:
|
|
if self._use_ssl:
|
|
conn = imaplib.IMAP4_SSL(self._imap_host, self._imap_port)
|
|
else:
|
|
conn = imaplib.IMAP4(self._imap_host, self._imap_port)
|
|
conn.login(self._username, self._password)
|
|
return conn
|
|
|