Initial commit: webmail client (M0/M1)
Three-pane webmail client. - Backend: FastAPI + async SQLAlchemy + arq worker (Postgres/Redis), IMAP/SMTP sync, threading, search, drafts/outbox with undo, attachments, 2FA. - Frontend: React 18 + Vite + TypeScript + TanStack Query + Tailwind; three-pane UI with rich-text composer, light/dark themes, resizable panels. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
@@ -0,0 +1 @@
|
||||
"""Outbox: drafts, MIME assembly, send queue, undo-send (SPEC §6.5)."""
|
||||
@@ -0,0 +1,161 @@
|
||||
"""The scheduled send job (SPEC §6.5).
|
||||
|
||||
Fires ``UNDO_SECONDS`` after the user hits send. If the outbox row was cancelled
|
||||
in the meantime, it does nothing (no SMTP traffic). Otherwise: SMTP send, append
|
||||
to Sent (skipped for Gmail, which self-appends), harvest recipients into
|
||||
``known_recipients`` (weight 3), and publish ``message.sent``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import uuid
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.dialects.postgresql import insert as pg_insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.db import session_scope
|
||||
from app.events import get_event_bus
|
||||
from app.indexer import blobstore
|
||||
from app.models import (
|
||||
Account,
|
||||
ComposeAttachment,
|
||||
Draft,
|
||||
KnownRecipient,
|
||||
Mailbox,
|
||||
Message,
|
||||
Outbox,
|
||||
)
|
||||
from app.outbox.mime_build import build_mime
|
||||
from app.sync.provider_factory import build_provider
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _is_gmail(account: Account) -> bool:
|
||||
host = str(account.imap_config.get("host", "")).lower()
|
||||
return "gmail.com" in host or "googlemail.com" in host
|
||||
|
||||
|
||||
async def _harvest_recipients(session: AsyncSession, user_id: uuid.UUID, emails: list[str]) -> None:
|
||||
now = datetime.now(UTC)
|
||||
for email in {e.lower() for e in emails if e}:
|
||||
stmt = pg_insert(KnownRecipient).values(
|
||||
user_id=user_id, email=email, name="", times_used=3, last_used_at=now
|
||||
)
|
||||
stmt = stmt.on_conflict_do_update(
|
||||
index_elements=[KnownRecipient.user_id, KnownRecipient.email],
|
||||
set_={
|
||||
"times_used": KnownRecipient.times_used + 3, # sent-to weight (SPEC §4)
|
||||
"last_used_at": stmt.excluded.last_used_at,
|
||||
},
|
||||
)
|
||||
await session.execute(stmt)
|
||||
|
||||
|
||||
async def _load_attachments(
|
||||
session: AsyncSession, user_id: uuid.UUID, draft: Draft
|
||||
) -> list[tuple[str, str, bytes]]:
|
||||
"""Resolve a draft's compose-attachment ids into (filename, mime, data) tuples."""
|
||||
raw_ids = draft.payload.get("attachment_ids") or []
|
||||
if not isinstance(raw_ids, list) or not raw_ids:
|
||||
return []
|
||||
ids: list[uuid.UUID] = []
|
||||
for value in raw_ids:
|
||||
try:
|
||||
ids.append(uuid.UUID(str(value)))
|
||||
except ValueError:
|
||||
continue
|
||||
if not ids:
|
||||
return []
|
||||
rows = await session.scalars(
|
||||
select(ComposeAttachment).where(
|
||||
ComposeAttachment.id.in_(ids), ComposeAttachment.user_id == user_id
|
||||
)
|
||||
)
|
||||
by_id = {r.id: r for r in rows}
|
||||
out: list[tuple[str, str, bytes]] = []
|
||||
for i in ids:
|
||||
att = by_id.get(i)
|
||||
if att is not None:
|
||||
out.append((att.filename, att.mime_type, blobstore.load(user_id, att.blob_sha256)))
|
||||
return out
|
||||
|
||||
|
||||
async def send_job(ctx: dict[str, Any], outbox_id: str) -> None:
|
||||
"""Send a queued message unless it was cancelled during the undo window."""
|
||||
oid = uuid.UUID(outbox_id)
|
||||
async with session_scope() as session:
|
||||
outbox = await session.get(Outbox, oid)
|
||||
if outbox is None or outbox.state != "undo_window":
|
||||
return # cancelled, or already handled -> no SMTP traffic
|
||||
outbox.state = "sending"
|
||||
draft = await session.get(Draft, outbox.draft_id)
|
||||
if draft is None:
|
||||
outbox.state = "failed"
|
||||
outbox.error = "draft missing"
|
||||
return
|
||||
account = await session.get(Account, draft.account_id)
|
||||
reply_to = (
|
||||
await session.get(Message, draft.reply_to_message_id)
|
||||
if draft.reply_to_message_id
|
||||
else None
|
||||
)
|
||||
if account is None:
|
||||
outbox.state = "failed"
|
||||
outbox.error = "account missing"
|
||||
return
|
||||
user_id = outbox.user_id
|
||||
attachments = await _load_attachments(session, user_id, draft)
|
||||
raw, envelope_from, envelope_to = build_mime(account, draft, reply_to, attachments)
|
||||
sent_path = await session.scalar(
|
||||
select(Mailbox.path).where(
|
||||
Mailbox.account_id == account.id, Mailbox.special_use == "sent"
|
||||
)
|
||||
)
|
||||
gmail = _is_gmail(account)
|
||||
account_obj = account
|
||||
|
||||
provider = build_provider(account_obj)
|
||||
try:
|
||||
await provider.send(raw, envelope_from, envelope_to)
|
||||
if sent_path and not gmail:
|
||||
await provider.append(sent_path, raw, frozenset({"\\Seen"}))
|
||||
except Exception as exc: # noqa: BLE001 - record and notify, keep the draft
|
||||
async with session_scope() as session:
|
||||
ob = await session.get(Outbox, oid)
|
||||
if ob is not None:
|
||||
ob.state = "failed"
|
||||
ob.error = str(exc)[:500]
|
||||
await get_event_bus().publish(
|
||||
"outbox.state_changed",
|
||||
{"user_id": str(user_id), "outbox_id": str(oid), "state": "failed"},
|
||||
)
|
||||
logger.exception("send failed for outbox %s", oid)
|
||||
return
|
||||
finally:
|
||||
await provider.close()
|
||||
|
||||
async with session_scope() as session:
|
||||
ob = await session.get(Outbox, oid)
|
||||
if ob is not None:
|
||||
ob.state = "sent"
|
||||
# The message left successfully: drop its draft so it no longer shows in
|
||||
# the Drafts folder (undo/cancel returns earlier, keeping the draft).
|
||||
draft_row = await session.get(Draft, draft.id)
|
||||
if draft_row is not None:
|
||||
await session.delete(draft_row)
|
||||
await _harvest_recipients(session, user_id, envelope_to)
|
||||
|
||||
bus = get_event_bus()
|
||||
await bus.publish(
|
||||
"message.sent",
|
||||
{"user_id": str(user_id), "outbox_id": str(oid), "thread_id": str(draft.thread_id)},
|
||||
)
|
||||
await bus.publish(
|
||||
"outbox.state_changed",
|
||||
{"user_id": str(user_id), "outbox_id": str(oid), "state": "sent"},
|
||||
)
|
||||
@@ -0,0 +1,102 @@
|
||||
"""Assemble an RFC822 message from a draft (SPEC §6.5).
|
||||
|
||||
Builds a multipart/alternative (auto-generated text from HTML), sets threading
|
||||
headers from the message being replied to, and returns the raw bytes plus the
|
||||
SMTP envelope. Attachment assembly is deferred to M2 (attachment upload).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
from email.message import EmailMessage
|
||||
from email.utils import format_datetime, make_msgid
|
||||
|
||||
import nh3
|
||||
|
||||
from app.models import Account, Draft, Message
|
||||
|
||||
|
||||
def _html_to_text(html: str) -> str:
|
||||
return nh3.clean(html, tags=set(), attributes={}, strip_comments=True)
|
||||
|
||||
|
||||
def _addr_list(values: object) -> list[str]:
|
||||
if not isinstance(values, list):
|
||||
return []
|
||||
out: list[str] = []
|
||||
for v in values:
|
||||
if isinstance(v, str) and v.strip():
|
||||
out.append(v.strip())
|
||||
elif isinstance(v, dict) and v.get("email"):
|
||||
name, email = v.get("name", ""), v["email"]
|
||||
out.append(f"{name} <{email}>" if name else str(email))
|
||||
return out
|
||||
|
||||
|
||||
def _email_only(formatted: str) -> str:
|
||||
if "<" in formatted and ">" in formatted:
|
||||
return formatted.split("<", 1)[1].split(">", 1)[0].strip()
|
||||
return formatted.strip()
|
||||
|
||||
|
||||
def _bracket(mid: str) -> str:
|
||||
mid = mid.strip()
|
||||
return mid if mid.startswith("<") else f"<{mid}>"
|
||||
|
||||
|
||||
def build_mime(
|
||||
account: Account,
|
||||
draft: Draft,
|
||||
reply_to: Message | None,
|
||||
attachments: list[tuple[str, str, bytes]] | None = None,
|
||||
) -> tuple[bytes, str, list[str]]:
|
||||
"""Return ``(raw_rfc822, envelope_from, envelope_to)`` for ``draft``.
|
||||
|
||||
``attachments`` is a list of ``(filename, mime_type, data)`` uploaded via the
|
||||
compose Attach action; each is added as a file attachment part.
|
||||
"""
|
||||
payload = draft.payload
|
||||
to = _addr_list(payload.get("to"))
|
||||
cc = _addr_list(payload.get("cc"))
|
||||
bcc = _addr_list(payload.get("bcc"))
|
||||
subject = str(payload.get("subject", ""))
|
||||
html = str(payload.get("html", "") or "")
|
||||
text = str(payload.get("text", "") or "")
|
||||
|
||||
msg = EmailMessage()
|
||||
from_name = account.display_name or ""
|
||||
msg["From"] = f"{from_name} <{account.email}>" if from_name else account.email
|
||||
if to:
|
||||
msg["To"] = ", ".join(to)
|
||||
if cc:
|
||||
msg["Cc"] = ", ".join(cc)
|
||||
msg["Subject"] = subject
|
||||
msg["Date"] = format_datetime(datetime.now(UTC))
|
||||
domain = account.email.rsplit("@", 1)[-1]
|
||||
msg["Message-ID"] = make_msgid(domain=domain)
|
||||
|
||||
# Threading headers so the recipient's client threads the reply (SPEC M1).
|
||||
if reply_to is not None and reply_to.message_id_hdr:
|
||||
parent = _bracket(reply_to.message_id_hdr)
|
||||
msg["In-Reply-To"] = parent
|
||||
refs = [_bracket(r) for r in reply_to.references_hdr] + [parent]
|
||||
msg["References"] = " ".join(refs)
|
||||
|
||||
# Body: text + HTML alternative (auto text when only HTML given).
|
||||
if html:
|
||||
msg.set_content(text or _html_to_text(html))
|
||||
msg.add_alternative(html, subtype="html")
|
||||
else:
|
||||
msg.set_content(text)
|
||||
|
||||
for filename, mime_type, data in attachments or []:
|
||||
maintype, _, subtype = mime_type.partition("/")
|
||||
msg.add_attachment(
|
||||
data,
|
||||
maintype=maintype or "application",
|
||||
subtype=subtype or "octet-stream",
|
||||
filename=filename,
|
||||
)
|
||||
|
||||
envelope_to = [_email_only(a) for a in (to + cc + bcc)]
|
||||
return msg.as_bytes(), account.email, envelope_to
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Compose/draft/send request & response models (SPEC §9.1)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class DraftPayload(BaseModel):
|
||||
to: list[str] = []
|
||||
cc: list[str] = []
|
||||
bcc: list[str] = []
|
||||
subject: str = ""
|
||||
html: str = ""
|
||||
text: str = ""
|
||||
attachment_ids: list[uuid.UUID] = []
|
||||
|
||||
|
||||
class DraftIn(BaseModel):
|
||||
account_id: uuid.UUID
|
||||
thread_id: uuid.UUID | None = None
|
||||
reply_to_message_id: uuid.UUID | None = None
|
||||
kind: str = "new" # reply | reply_all | forward | new
|
||||
payload: DraftPayload
|
||||
|
||||
|
||||
class DraftOut(BaseModel):
|
||||
id: uuid.UUID
|
||||
account_id: uuid.UUID
|
||||
thread_id: uuid.UUID | None
|
||||
reply_to_message_id: uuid.UUID | None
|
||||
kind: str
|
||||
payload: dict[str, object]
|
||||
updated_at: str
|
||||
|
||||
|
||||
class SendRequest(BaseModel):
|
||||
draft_id: uuid.UUID
|
||||
|
||||
|
||||
class SendResponse(BaseModel):
|
||||
outbox_id: uuid.UUID
|
||||
undo_until: str
|
||||
|
||||
|
||||
class OutboxStateOut(BaseModel):
|
||||
outbox_id: uuid.UUID
|
||||
state: str
|
||||
@@ -0,0 +1,76 @@
|
||||
"""Draft persistence and the send/undo flow (SPEC §6.5)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import get_settings
|
||||
from app.models import Account, Draft, Outbox
|
||||
from app.outbox.schemas import DraftIn
|
||||
|
||||
|
||||
class DraftError(Exception):
|
||||
"""Draft could not be created/updated (e.g. account not owned)."""
|
||||
|
||||
|
||||
async def upsert_draft(
|
||||
session: AsyncSession, *, user_id: uuid.UUID, body: DraftIn, draft_id: uuid.UUID | None
|
||||
) -> Draft:
|
||||
"""Create or update a draft owned by ``user_id``."""
|
||||
account = await session.scalar(
|
||||
select(Account).where(Account.id == body.account_id, Account.user_id == user_id)
|
||||
)
|
||||
if account is None:
|
||||
raise DraftError("account not found")
|
||||
|
||||
payload = body.payload.model_dump(mode="json")
|
||||
if draft_id is None:
|
||||
draft = Draft(
|
||||
user_id=user_id,
|
||||
account_id=body.account_id,
|
||||
thread_id=body.thread_id,
|
||||
reply_to_message_id=body.reply_to_message_id,
|
||||
kind=body.kind,
|
||||
payload=payload,
|
||||
)
|
||||
session.add(draft)
|
||||
else:
|
||||
fetched = await session.scalar(
|
||||
select(Draft).where(Draft.id == draft_id, Draft.user_id == user_id)
|
||||
)
|
||||
if fetched is None:
|
||||
raise DraftError("draft not found")
|
||||
draft = fetched
|
||||
draft.account_id = body.account_id
|
||||
draft.thread_id = body.thread_id
|
||||
draft.reply_to_message_id = body.reply_to_message_id
|
||||
draft.kind = body.kind
|
||||
draft.payload = payload
|
||||
draft.updated_at = datetime.now(UTC)
|
||||
await session.flush()
|
||||
return draft
|
||||
|
||||
|
||||
async def create_outbox(session: AsyncSession, *, user_id: uuid.UUID, draft: Draft) -> Outbox:
|
||||
"""Create an outbox row in the undo window for a draft."""
|
||||
send_after = datetime.now(UTC) + timedelta(seconds=get_settings().undo_seconds)
|
||||
outbox = Outbox(user_id=user_id, draft_id=draft.id, state="undo_window", send_after=send_after)
|
||||
session.add(outbox)
|
||||
await session.flush()
|
||||
return outbox
|
||||
|
||||
|
||||
async def cancel_outbox(session: AsyncSession, *, user_id: uuid.UUID, outbox_id: uuid.UUID) -> bool:
|
||||
"""Cancel a send if still in the undo window. Returns False if too late/unknown."""
|
||||
outbox = await session.scalar(
|
||||
select(Outbox).where(Outbox.id == outbox_id, Outbox.user_id == user_id)
|
||||
)
|
||||
if outbox is None or outbox.state != "undo_window":
|
||||
return False
|
||||
outbox.state = "cancelled"
|
||||
await session.flush()
|
||||
return True
|
||||
Reference in New Issue
Block a user