flowbox 0.1.0__py3-none-any.whl

flowbox/adapters/_imap.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import base64
+import contextlib
+import imaplib
+import re
+import ssl
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta, timezone
+from typing import Any, TypeVar
+
+from flowbox._exceptions import AdapterError
+from flowbox._message import Message
+from flowbox._mime import from_mime
+from flowbox.adapters._abc import Encryption, InboxAdapterABC
+
+T = TypeVar("T")
+
+_DEFAULT_PORTS: dict[Encryption, int] = {"ssl": 993, "starttls": 143, "none": 143}
+
+# IMAP dates are always English, whatever the locale strftime/strptime would use.
+_MONTHS = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+
+# Messages per UID FETCH, which keeps the command line under server limits.
+_FETCH_CHUNK = 100
+
+_LIST_PATTERN = re.compile(rb'\((?P<flags>[^)]*)\) (?P<delimiter>"(?:[^"\\]|\\.)*"|NIL) (?P<name>.+)')
+_UID_PATTERN = re.compile(rb"UID (\d+)")
+_INTERNALDATE_PATTERN = re.compile(rb'INTERNALDATE "(\d{1,2})-(\w{3})-(\d{4}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})"')
+
+
+def encode_mailbox_name(name: str) -> str:
+    """IMAP's modified UTF-7 (RFC 3501, 5.1.3): what servers expect for any
+    mailbox name outside printable ASCII, e.g. ``"Entwürfe"``."""
+    encoded: list[str] = []
+    pending: list[str] = []
+
+    def _flush() -> None:
+        if pending:
+            raw = "".join(pending).encode("utf-16-be")
+            encoded.append("&" + base64.b64encode(raw).decode("ascii").rstrip("=").replace("/", ",") + "-")
+            pending.clear()
+
+    for char in name:
+        if 0x20 <= ord(char) <= 0x7E:
+            _flush()
+            encoded.append("&-" if char == "&" else char)
+        else:
+            pending.append(char)
+    _flush()
+
+    return "".join(encoded)
+
+
+def decode_mailbox_name(name: str) -> str:
+    def _decode(match: re.Match[str]) -> str:
+        chunk = match.group(1)
+        if not chunk:
+            return "&"
+        chunk = chunk.replace(",", "/")
+        return base64.b64decode(chunk + "=" * (-len(chunk) % 4)).decode("utf-16-be")
+
+    return re.sub(r"&([A-Za-z0-9+,]*)-", _decode, name)
+
+
+def _quote(value: str) -> str:
+    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _unquote(value: bytes) -> str:
+    text = value.decode("utf-8", errors="replace")
+    if len(text) >= 2 and text[0] == text[-1] == '"':
+        text = text[1:-1].replace('\\"', '"').replace("\\\\", "\\")
+    return text
+
+
+def _imap_date(value: datetime) -> str:
+    return f"{value.day:02d}-{_MONTHS[value.month - 1]}-{value.year}"
+
+
+def _parse_internaldate(meta: bytes) -> datetime | None:
+    match = _INTERNALDATE_PATTERN.search(meta)
+    if match is None:
+        return None
+
+    day, month, year, hour, minute, second, sign, offset_hours, offset_minutes = match.groups()
+    offset = timedelta(hours=int(offset_hours), minutes=int(offset_minutes))
+
+    return datetime(
+        int(year),
+        _MONTHS.index(month.decode("ascii").title()) + 1,
+        int(day),
+        int(hour),
+        int(minute),
+        int(second),
+        tzinfo=timezone(-offset if sign == b"-" else offset),
+    )
+
+
+class IMAPAdapter(InboxAdapterABC):
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: str,
+        port: int | None = None,
+        encryption: Encryption = "ssl",
+        timeout: float | None = 30.0,
+        ssl_context: ssl.SSLContext | None = None,
+    ) -> None:
+        super().__init__(driver_name="imap")
+
+        self._host = host
+        self._username = username
+        self._password = password
+        self._port = port or _DEFAULT_PORTS[encryption]
+        self._encryption = encryption
+        self._timeout = timeout
+        self._ssl_context = ssl_context
+        self._client: imaplib.IMAP4 | None = None
+
+    def _connect(self) -> imaplib.IMAP4:
+        context = self._ssl_context or ssl.create_default_context()
+
+        try:
+            client: imaplib.IMAP4
+            if self._encryption == "ssl":
+                client = imaplib.IMAP4_SSL(self._host, self._port, ssl_context=context, timeout=self._timeout)
+            else:
+                client = imaplib.IMAP4(self._host, self._port, timeout=self._timeout)
+                if self._encryption == "starttls":
+                    client.starttls(ssl_context=context)
+
+            client.login(self._username, self._password)
+        except (imaplib.IMAP4.error, OSError) as exc:
+            raise AdapterError(f"could not connect to IMAP server {self._host}:{self._port}: {exc}") from exc
+
+        return client
+
+    def _disconnect(self) -> None:
+        client, self._client = self._client, None
+        if client is None:
+            return
+
+        with contextlib.suppress(Exception):
+            client.logout()
+
+    def is_connected(self) -> bool:
+        return self._client is not None
+
+    def reconnect(self) -> None:
+        self._disconnect()
+        self._client = self._connect()
+
+    def close(self) -> None:
+        self._disconnect()
+
+    def _call(self, operation: Callable[[imaplib.IMAP4], T]) -> T:
+        """Runs ``operation`` on the open connection, opening one first if needed.
+
+        Servers drop idle connections, which only shows on the next command, so a
+        dropped connection is reopened and the operation retried once."""
+        if self._client is None:
+            self._client = self._connect()
+
+        try:
+            return operation(self._client)
+        except (imaplib.IMAP4.abort, OSError):
+            self.reconnect()
+            assert self._client is not None
+            return operation(self._client)
+        except imaplib.IMAP4.error as exc:
+            raise AdapterError(f"IMAP command failed: {exc}") from exc
+
+    @staticmethod
+    def _check(response: tuple[str, list[Any]], command: str) -> list[Any]:
+        status, data = response
+        if status != "OK":
+            raise AdapterError(f"IMAP {command} failed: {data!r}")
+        return data
+
+    def get_mailboxes(self) -> list[str]:
+        def _list(client: imaplib.IMAP4) -> list[str]:
+            mailboxes: list[str] = []
+
+            for line in self._check(client.list(), "LIST"):
+                if not isinstance(line, bytes):
+                    continue
+
+                match = _LIST_PATTERN.match(line)
+                if match is None or b"\\noselect" in match.group("flags").lower():
+                    continue
+
+                mailboxes.append(decode_mailbox_name(_unquote(match.group("name"))))
+
+            return mailboxes
+
+        return self._call(_list)
+
+    def retrieve_mails(self, mailbox: str, from_datetime: datetime) -> list[Message]:
+        since = from_datetime.astimezone(UTC)
+
+        def _retrieve(client: imaplib.IMAP4) -> list[Message]:
+            self._check(client.select(_quote(encode_mailbox_name(mailbox)), readonly=True), "SELECT")
+
+            # SEARCH SINCE only knows dates, in the server's own timezone; a day of
+            # slack covers that, and INTERNALDATE narrows it down exactly below.
+            data = self._check(client.uid("SEARCH", "SINCE", _imap_date(since - timedelta(days=1))), "SEARCH")
+            uids = data[0].split() if data and data[0] else []
+
+            messages: list[Message] = []
+            for start in range(0, len(uids), _FETCH_CHUNK):
+                chunk = b",".join(uids[start : start + _FETCH_CHUNK]).decode("ascii")
+                response = client.uid("FETCH", chunk, "(UID INTERNALDATE BODY.PEEK[])")
+                messages.extend(self._parse_fetch(self._check(response, "FETCH")))
+
+            messages = [message for message in messages if message.received_at is None or message.received_at >= since]
+            messages.sort(key=lambda message: int(message.id or 0))
+            return messages
+
+        return self._call(_retrieve)
+
+    @staticmethod
+    def _parse_fetch(data: list[Any]) -> list[Message]:
+        """A FETCH response is a ``(meta, literal)`` tuple per message, followed by
+        a closing ``b")"`` -- into which some servers put the UID or INTERNALDATE
+        after the body, so that trailing chunk counts as meta as well."""
+        records: list[tuple[bytes, bytes]] = []
+
+        for item in data:
+            if isinstance(item, tuple):
+                records.append((item[0], item[1]))
+            elif isinstance(item, bytes) and records:
+                meta, raw = records[-1]
+                records[-1] = (meta + item, raw)
+
+        messages: list[Message] = []
+        for meta, raw in records:
+            uid = _UID_PATTERN.search(meta)
+            message = from_mime(raw)
+            message.id = uid.group(1).decode("ascii") if uid else None
+            message.received_at = _parse_internaldate(meta) or message.received_at
+            messages.append(message)
+
+        return messages

flowbox/adapters/_lettermint.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from collections.abc import Mapping
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from flowbox._exceptions import AdapterError, SignatureError
+from flowbox._message import Address, Attachment, Message
+from flowbox._mime import from_mime
+from flowbox.adapters._abc import InboxAdapterABC, OutboxAdapterABC, WebhookInboxAdapterABC, require_sender
+
+_BASE_URL = "https://api.lettermint.co/v1"
+
+
+def _datetime(value: str) -> datetime:
+    parsed = datetime.fromisoformat(value)
+    return parsed if parsed.tzinfo is not None else parsed.replace(tzinfo=UTC)
+
+
+def _address(value: dict[str, Any]) -> Address:
+    return Address(email=value["email"], name=value.get("name") or None)
+
+
+class LettermintAdapter(InboxAdapterABC, WebhookInboxAdapterABC, OutboxAdapterABC):
+    """Each capability needs its own credential, and only that one:
+
+    - sending: a project token (``lm_...``) for the Sending API
+    - retrieve_mails(): a team token (``lm_team_...``) for the Team API
+    - parse_webhook(): the inbound route webhook's signing secret (``whsec_...``)
+    """
+
+    def __init__(
+        self,
+        project_token: str | None = None,
+        team_token: str | None = None,
+        webhook_secret: str | None = None,
+        project_id: str | None = None,
+        route: str | None = None,
+        base_url: str = _BASE_URL,
+        timeout: float = 30.0,
+        webhook_tolerance: int = 300,
+    ) -> None:
+        super().__init__(driver_name="lettermint")
+
+        self._project_token = project_token
+        self._team_token = team_token
+        self._webhook_secret = webhook_secret
+        #: How far, in seconds, a webhook's signed timestamp may be off: replay protection.
+        self._webhook_tolerance = webhook_tolerance
+        #: Limits get_mailboxes() to one project's routes; all projects otherwise.
+        self._project_id = project_id
+        #: The route outgoing mail is sent through; the project's default otherwise.
+        self._route = route
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._route_ids: dict[str, list[str]] | None = None
+
+    # -- outbox -----------------------------------------------------------------
+
+    def send_mail(self, message: Message) -> str:
+        if self._project_token is None:
+            raise AdapterError("sending through Lettermint needs a project token")
+
+        response = self._json("POST", "/send", {"x-lettermint-token": self._project_token}, self._payload(message))
+        return str(response["message_id"])
+
+    def _payload(self, message: Message) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "from": str(require_sender(message)),
+            "to": [str(address) for address in message.to],
+            "subject": message.subject,
+        }
+
+        for key, addresses in (("cc", message.cc), ("bcc", message.bcc), ("reply_to", message.reply_to)):
+            if addresses:
+                payload[key] = [str(address) for address in addresses]
+
+        if message.text is not None:
+            payload["text"] = message.text
+        if message.html is not None:
+            payload["html"] = message.html
+        if message.headers:
+            payload["headers"] = dict(message.headers)
+        if self._route is not None:
+            payload["route"] = self._route
+
+        if message.attachments:
+            payload["attachments"] = [
+                {
+                    "filename": attachment.filename,
+                    "content": base64.b64encode(attachment.content).decode("ascii"),
+                    "content_type": attachment.content_type,
+                    **({"content_id": attachment.content_id} if attachment.content_id else {}),
+                }
+                for attachment in message.attachments
+            ]
+
+        return payload
+
+    # -- inbox ------------------------------------------------------------------
+
+    def get_mailboxes(self) -> list[str]:
+        """The slugs of the team's inbound routes."""
+        route_ids: dict[str, list[str]] = {}
+
+        project_ids = [self._project_id] if self._project_id else [p["id"] for p in self._paginate("/projects", {})]
+        for project_id in project_ids:
+            for route in self._paginate(f"/projects/{project_id}/routes", {"filter[route_type]": "inbound"}):
+                route_ids.setdefault(route["slug"], []).append(route["id"])
+
+        self._route_ids = route_ids
+        return list(route_ids)
+
+    def retrieve_mails(self, mailbox: str, from_datetime: datetime) -> list[Message]:
+        """``mailbox`` is a route slug from get_mailboxes(), or a route id."""
+        since = from_datetime.astimezone(UTC)
+        params = {
+            "filter[type]": "inbound",
+            "filter[route_id]": self._resolve_route_id(mailbox),
+            # The filter only takes a date, and "after" may exclude the day
+            # itself; a day of slack covers both, created_at narrows it down.
+            "filter[from_date]": (since - timedelta(days=1)).date().isoformat(),
+            "sort": "created_at",
+        }
+
+        messages: list[Message] = []
+        for item in self._paginate("/messages", params):
+            received_at = _datetime(item["created_at"])
+            if received_at < since:
+                continue
+
+            message = from_mime(self._request("GET", f"/messages/{item['id']}/source", self._team_headers()))
+            message.id = item["id"]
+            message.received_at = received_at
+            messages.append(message)
+
+        return messages
+
+    # -- webhooks ---------------------------------------------------------------
+
+    def parse_webhook(self, body: bytes, headers: Mapping[str, str]) -> Message:
+        """Translates a ``message.inbound`` webhook from an inbound route.
+
+        Lettermint retries a delivery it got no 2xx for, with the same payload,
+        so the same message can arrive twice; its id stays the same."""
+        self._verify_signature(body, headers)
+
+        try:
+            event = json.loads(body)
+        except ValueError as exc:
+            raise AdapterError("Lettermint webhook body is not valid JSON") from exc
+
+        if not isinstance(event, dict) or event.get("event") != "message.inbound":
+            kind = event.get("event") if isinstance(event, dict) else None
+            raise AdapterError(f"expected a message.inbound webhook, got {kind!r}")
+
+        return self._inbound_message(event["data"])
+
+    def _verify_signature(self, body: bytes, headers: Mapping[str, str]) -> None:
+        """``X-Lettermint-Signature: t=<unix time>,v1=<hex>``, where v1 is the
+        HMAC-SHA256 of ``"<t>.<body>"`` keyed with the whole ``whsec_`` secret."""
+        if self._webhook_secret is None:
+            raise AdapterError("verifying Lettermint webhooks needs the webhook signing secret")
+
+        signature = next((value for name, value in headers.items() if name.lower() == "x-lettermint-signature"), None)
+        if signature is None:
+            raise SignatureError("the request has no X-Lettermint-Signature header")
+
+        parts = dict(part.split("=", 1) for part in signature.split(",") if "=" in part)
+        timestamp, received = parts.get("t", ""), parts.get("v1", "")
+        if not timestamp.isdigit() or not received:
+            raise SignatureError("the X-Lettermint-Signature header is malformed")
+
+        if abs(time.time() - int(timestamp)) > self._webhook_tolerance:
+            raise SignatureError("the webhook's signed timestamp is too old or too far ahead")
+
+        signed = timestamp.encode("ascii") + b"." + body
+        expected = hmac.new(self._webhook_secret.encode("utf-8"), signed, hashlib.sha256).hexdigest()
+        if not hmac.compare_digest(expected, received):
+            raise SignatureError("the webhook signature does not match")
+
+    def _inbound_message(self, data: dict[str, Any]) -> Message:
+        body = data.get("body") or {}
+        reply_to = data.get("reply_to")
+
+        return Message(
+            subject=data.get("subject") or "",
+            sender=_address(data["from"]) if data.get("from") else None,
+            to=[_address(value) for value in data.get("to") or []],
+            cc=[_address(value) for value in data.get("cc") or []],
+            reply_to=[Address.parse(reply_to)] if isinstance(reply_to, str) and reply_to else [],
+            text=body.get("text"),
+            html=body.get("html"),
+            attachments=[self._inbound_attachment(value) for value in data.get("attachments") or []],
+            headers={header["name"]: header["value"] for header in data.get("headers") or []},
+            id=data.get("message_id"),
+            received_at=_datetime(data["date"]) if data.get("date") else None,
+        )
+
+    def _inbound_attachment(self, value: dict[str, Any]) -> Attachment:
+        """Small files come inline as base64; a route set to deliver attachments
+        by URL sends a signed download link instead, valid for a limited time."""
+        if value.get("content") is not None:
+            content = base64.b64decode(value["content"])
+        elif value.get("url"):
+            content = self._download(value["url"])
+        else:
+            content = b""
+
+        return Attachment(
+            filename=value.get("filename") or "attachment",
+            content=content,
+            content_type=value.get("content_type") or "",
+            content_id=value.get("content_id"),
+        )
+
+    def _download(self, url: str) -> bytes:
+        request = urllib.request.Request(url, headers={"User-Agent": "flowbox"})
+
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                content: bytes = response.read()
+                return content
+        except (urllib.error.URLError, OSError) as exc:
+            raise AdapterError(f"could not download Lettermint attachment: {exc}") from exc
+
+    def _resolve_route_id(self, mailbox: str) -> str:
+        if self._route_ids is None or mailbox not in self._route_ids:
+            self.get_mailboxes()
+        assert self._route_ids is not None
+
+        route_ids = self._route_ids.get(mailbox)
+        if route_ids is None:
+            return mailbox
+        if len(route_ids) > 1:
+            raise AdapterError(f"route slug {mailbox!r} exists in several projects; pass its route id instead")
+        return route_ids[0]
+
+    def _team_headers(self) -> dict[str, str]:
+        if self._team_token is None:
+            raise AdapterError("reading Lettermint inbound mail needs a team token")
+        return {"Authorization": f"Bearer {self._team_token}"}
+
+    def _paginate(self, path: str, params: dict[str, str]) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        cursor: str | None = None
+
+        while True:
+            query = {**params, "page[cursor]": cursor} if cursor else params
+            page = self._json("GET", f"{path}?{urllib.parse.urlencode(query)}", self._team_headers())
+            items.extend(page.get("data") or [])
+
+            cursor = page.get("next_cursor")
+            if not cursor:
+                return items
+
+    # -- http -------------------------------------------------------------------
+
+    def _json(
+        self, method: str, path: str, headers: dict[str, str], payload: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        body = self._request(method, path, {**headers, "Accept": "application/json"}, payload)
+
+        try:
+            decoded = json.loads(body)
+        except ValueError as exc:
+            raise AdapterError(f"Lettermint returned invalid JSON for {method} {path}") from exc
+
+        if not isinstance(decoded, dict):
+            raise AdapterError(f"Lettermint returned unexpected JSON for {method} {path}")
+        return decoded
+
+    def _request(
+        self, method: str, path: str, headers: dict[str, str], payload: dict[str, Any] | None = None
+    ) -> bytes:
+        data = json.dumps(payload).encode("utf-8") if payload is not None else None
+        request = urllib.request.Request(
+            self._base_url + path,
+            data=data,
+            method=method,
+            headers={
+                **headers,
+                "User-Agent": "flowbox",
+                **({"Content-Type": "application/json"} if data is not None else {}),
+            },
+        )
+
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                body: bytes = response.read()
+                return body
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", errors="replace")
+            raise AdapterError(f"Lettermint {method} {path} failed with HTTP {exc.code}: {detail}") from exc
+        except (urllib.error.URLError, OSError) as exc:
+            raise AdapterError(f"could not reach Lettermint: {exc}") from exc

flowbox/adapters/_log.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import logging
+import uuid
+
+from flowbox._message import Message
+from flowbox.adapters._abc import OutboxAdapterABC
+
+logger = logging.getLogger("flowbox.log")
+
+
+class LogAdapter(OutboxAdapterABC):
+    """Sends nothing: logs each message at INFO on the ``flowbox.log`` logger,
+    like Laravel's log mailer. For local development and demos; the log holds
+    the recipients and subject, so keep it out of production."""
+
+    def __init__(self) -> None:
+        super().__init__(driver_name="log")
+
+    def send_mail(self, message: Message) -> str:
+        message_id = f"log-{uuid.uuid4()}"
+        recipients = ", ".join(address.email for address in (*message.to, *message.cc, *message.bcc))
+        logger.info("Mail %s %r to %s (not sent)", message_id, message.subject, recipients)
+        return message_id

flowbox/adapters/_smtp.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import contextlib
+import smtplib
+import ssl
+from email.message import EmailMessage
+from email.utils import make_msgid
+
+from flowbox._exceptions import AdapterError
+from flowbox._message import Message
+from flowbox._mime import to_mime
+from flowbox.adapters._abc import Encryption, OutboxAdapterABC, require_sender
+
+_DEFAULT_PORTS: dict[Encryption, int] = {"ssl": 465, "starttls": 587, "none": 25}
+
+
+class SMTPAdapter(OutboxAdapterABC):
+    def __init__(
+        self,
+        host: str,
+        username: str | None = None,
+        password: str | None = None,
+        port: int | None = None,
+        encryption: Encryption = "starttls",
+        timeout: float = 30.0,
+        local_hostname: str | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+    ) -> None:
+        super().__init__(driver_name="smtp")
+
+        self._host = host
+        self._username = username
+        self._password = password
+        self._port = port or _DEFAULT_PORTS[encryption]
+        self._encryption = encryption
+        self._timeout = timeout
+        self._local_hostname = local_hostname
+        self._ssl_context = ssl_context
+        self._client: smtplib.SMTP | None = None
+
+    def _connect(self) -> smtplib.SMTP:
+        context = self._ssl_context or ssl.create_default_context()
+
+        try:
+            client: smtplib.SMTP
+            if self._encryption == "ssl":
+                client = smtplib.SMTP_SSL(
+                    self._host, self._port, self._local_hostname, timeout=self._timeout, context=context
+                )
+            else:
+                client = smtplib.SMTP(self._host, self._port, self._local_hostname, timeout=self._timeout)
+                if self._encryption == "starttls":
+                    client.starttls(context=context)
+
+            if self._username is not None:
+                client.login(self._username, self._password or "")
+        except (smtplib.SMTPException, OSError) as exc:
+            raise AdapterError(f"could not connect to SMTP server {self._host}:{self._port}: {exc}") from exc
+
+        return client
+
+    def _disconnect(self) -> None:
+        client, self._client = self._client, None
+        if client is None:
+            return
+
+        try:
+            client.quit()
+        except (smtplib.SMTPException, OSError):
+            with contextlib.suppress(Exception):
+                client.close()
+
+    def is_connected(self) -> bool:
+        return self._client is not None
+
+    def reconnect(self) -> None:
+        self._disconnect()
+        self._client = self._connect()
+
+    def close(self) -> None:
+        self._disconnect()
+
+    def send_mail(self, message: Message) -> str:
+        """Returns the Message-ID header, which is the only id SMTP has.
+
+        Recipients the server refuses while accepting others are not an error:
+        the message is already on its way to the rest, and raising would invite a
+        retry that sends it to them twice."""
+        sender = require_sender(message)
+        message_id = message.headers.get("Message-ID") or make_msgid(domain=sender.email.rpartition("@")[2] or None)
+        mime = to_mime(message, sender, message_id)
+        recipients = [address.email for address in (*message.to, *message.cc, *message.bcc)]
+
+        try:
+            self._send(mime, sender.email, recipients)
+        except smtplib.SMTPServerDisconnected:
+            # Servers close idle connections; that only shows on the next command.
+            self.reconnect()
+            self._send(mime, sender.email, recipients)
+
+        return message_id
+
+    def _send(self, mime: EmailMessage, sender: str, recipients: list[str]) -> None:
+        if self._client is None:
+            self._client = self._connect()
+
+        try:
+            self._client.send_message(mime, from_addr=sender, to_addrs=recipients)
+        except smtplib.SMTPServerDisconnected:
+            raise
+        except (smtplib.SMTPException, OSError) as exc:
+            raise AdapterError(f"SMTP send failed: {exc}") from exc