# Blueprint: Mail-Bridge

Version 1.0 · denzer.ai · Lizenz: frei nutzbar mit Quellenangabe

Lese-Anbindung an Gmail und Versand über Resend (oder eigenen SMTP), beides aus deinem Agent heraus. Dein Agent sieht deine wichtigsten Mails, schreibt Drafts in deinem Stil, und verschickt nur auf deinen Befehl.

**Fallbeispiel.** Du hast zwei Mail-Konten (`christian@denzer.ai` und `itssoawsome@gmail.com`), Drafts willst du in deiner Stimme bekommen, Versand soll aus `denzer.ai` raus (geschäftlich), Newsletter und Werbung sollen automatisch in einen Side-Channel verschoben werden, der Agent soll daraus drei Mal pro Woche eine Briefing-Zusammenfassung machen.

---

## Teil B — Für dich (Operator)

### Was ist das?

Zwei Brücken in einer: **Lesen** über die Gmail-API (oder IMAP, je nach Anbieter), **Senden** über einen modernen Mail-Versender wie Resend (oder eigenen SMTP). Dein Agent fragt den Lese-Endpoint nach neuen Mails, fasst zusammen, schlägt Drafts vor. Beim Senden trägst du Empfänger, Betreff, Text ein, der Versand läuft über deine eigene Absender-Domain.

Wichtig: Gmail-Versand selbst aus einem Skript ist heikel (App-Passwörter, OAuth-Tanz, Spam-Verdacht). Deshalb der Trick: lesen über Gmail, **senden über eine eigene Domain mit Resend**. Sieht professioneller aus, kommt sauberer durch.

### Warum so und nicht anders?

Drei naheliegende Alternativen:

1. **Alles über Gmail (Lesen und Senden).** Schnell aufgesetzt, aber Versand aus `@gmail.com` wirkt im Geschäftskontext laienhaft, App-Passwörter werden von Google langsam abgeschafft, OAuth für Send-Scopes ist enger reguliert.
2. **SMTP über deinen Hoster.** Klassisch, aber Reputation-Management, Bounces und DKIM-Setup machst du selbst — viel Hand-Arbeit für etwas, das Tools heute lösen.
3. **Alles über Resend (auch Lesen).** Resend kann nicht lesen, nur senden. Würde dich zwingen, einen zweiten IMAP-Client einzubauen.

Daher die Hybrid-Lösung: **Gmail-API zum Lesen** (offiziell, stabil, Refresh-Tokens halten), **Resend zum Senden** (deine eigene Domain, sauberes DKIM/SPF/DMARC, Webhooks für Bounces, gute Deliverability). Beide kostenlos im Einstieg, klare Trennung der Verantwortung.

Eigene Versand-Domain statt Gmail-Adresse, weil Mails von `@gmail.com` in B2B-Kontexten unprofessionell wirken und schneller im Spam landen.

### Was brauchst du dafür?

- Ein Google-Konto mit aktivierter Gmail-API (kostenlos)
- Eine eigene Domain für den Versand (z. B. `denzer.ai`)
- Einen Resend-Account (kostenlos bis 100 Mails/Tag, danach günstig)
- DNS-Zugriff auf deine Domain, um DKIM/SPF einzutragen (einmalig 10 Minuten)

### Wie startest du?

1. Starter laden, deinem Agent geben
2. Sagen: "richte mir die Mail-Bridge ein, Lesen von Gmail, Senden über Resend mit Absender `christian@denzer.ai`"
3. Agent führt dich durch die Gmail-Authorisierung (OAuth-Klick im Browser)
4. Agent zeigt dir die DNS-Einträge für deine Domain (DKIM, SPF, DMARC), die du bei deinem Hoster einträgst
5. Agent schickt eine Test-Mail an dich selbst, du prüfst Zustellung und Absender

### Wo sind die Grenzen?

- Resend kann nicht aus `@gmail.com` versenden — Versand braucht eine eigene Domain
- Beim ersten Senden aus einer neuen Domain landest du oft im Spam, bis die Domain Reputation aufgebaut hat (paar Tage). Faustregel: erste Woche nur an Adressen, die dich kennen
- Mail-Lesen ist immer "fast", nicht "live" — typische Latenz 30–120 Sekunden
- Eingehende Mails über deine eigene Domain laufen weiter über deinen Hoster (Forwarding zu Gmail), nicht über Resend

### Was kostet das?

- Resend: 0 € bis 100 Mails/Tag, danach ~20 USD/Monat für 50.000 Mails
- Gmail-API: kostenlos
- Domain: schon vorhanden
- Modell-Kosten: ein paar Cent pro Draft

### Wann lohnt es sich, wann nicht?

Lohnt sich, wenn du regelmäßig mit Kunden mailst und einen wiedererkennbaren Schreibstil pflegst. Lohnt sich nicht, wenn Mail bei dir nur Pflichtkommunikation ohne Eigenstil ist.

### Wie weißt du, dass es funktioniert?

- Eingehende Mails erscheinen in der Agent-Oberfläche, gefiltert nach Wichtigkeit
- Drafts klingen nach dir (vergleiche mit deinen letzten 30 Sent-Mails)
- Test-Mail an Gmail landet im Posteingang, nicht im Spam
- DMARC-Report nach 7 Tagen zeigt 0 Fehlversuche

### Stolpersteine

- **DKIM-Konflikt.** Wenn du bisher Mails über Google Workspace verschickt hast, gibt es schon einen DKIM-Eintrag. Resend braucht einen eigenen Selector — beide können parallel existieren
- **OAuth-Token läuft ab.** Gmail-Refresh-Token muss persistent gespeichert sein, sonst musst du alle 60 Minuten neu autorisieren
- **Antwort-Threading.** Wenn du auf eine Mail antwortest, muss der `In-Reply-To`-Header korrekt gesetzt sein, sonst wird's eine neue Konversation
- **Reply-To vs From.** Wenn du aus `christian@denzer.ai` sendest und Antworten an Gmail willst, setzt du `Reply-To: itssoawsome@gmail.com`
- **Versand-Limit.** Resend drosselt bei zu vielen Mails an unbekannte Empfänger, langsam aufwärmen

---

## Teil A — Für deinen Agent

### Agent-Triggersätze

- "Richte mir die Mail-Bridge ein"
- "Verbinde Klaus mit meinem Gmail"
- "Mach dass ich aus dem Agent Mails über `<domain>` verschicken kann"

### Ziel

Lese-Anbindung an Gmail via Gmail-API (Labels, Threads, Suche), Versand via Resend API mit eigener Absender-Domain. Drafts vom Agent erzeugt, Versand nur auf User-Trigger.

### Erfolgskriterien

- Eingehende Mails (gefiltert nach Label und Wichtigkeit) verfügbar via REST
- Volltextsuche über Threads
- Send-Endpoint mit `from`, `to`, `subject`, `text`, `html?`, `reply_to?`, `in_reply_to?`
- DNS-Setup-Anleitung als Output des Setup-Skripts (DKIM/SPF/DMARC)
- OAuth-Refresh läuft automatisch
- Outbound nur mit User-Trigger, niemals autonom

### Eingabe-Schema

```yaml
read:
  provider:        "gmail"
  account:         "itssoawsome@gmail.com"
  oauth_creds:     "<root>/.config/gmail-oauth.json"
  refresh_token:   "<root>/.config/gmail-refresh-token"
  labels_track:    ["INBOX", "STARRED", "Kunden"]
  fetch_interval:  60                                # Sekunden
send:
  provider:        "resend"
  api_key_env:     "RESEND_API_KEY"
  from_default:    "christian@denzer.ai"
  reply_to:        "itssoawsome@gmail.com"
  domain:          "denzer.ai"
api:
  bind:            "127.0.0.1:8890"
```

### Verarbeitung

1. **OAuth-Setup** — einmaliger Browser-Auth, Refresh-Token persistieren
2. **Polling** — alle `fetch_interval` Sekunden neue Mails über Gmail-API ziehen, in DB schreiben
3. **Trigger-Mails** — bestimmte Labels (z. B. `Kunden`) lösen Agent-Benachrichtigung aus
4. **Draft-API** — Agent erzeugt Draft im User-Stil, Operator prüft, gibt frei
5. **Send** — Resend-API mit kompletten Headers (`Message-Id`, `In-Reply-To`, `References`)
6. **DNS-Check** — Setup-Skript zeigt DKIM/SPF/DMARC-Records, prüft nach 24h Status

### Endpoints

| Methode | Pfad | Zweck |
|---|---|---|
| GET | `/api/mail/threads?label=INBOX&limit=20` | Thread-Liste |
| GET | `/api/mail/thread/<id>` | Voller Thread inkl. Body |
| GET | `/api/mail/search?q=...` | Suche |
| POST | `/api/mail/send` | Versenden, Body: `{from, to, subject, text, ...}` |
| GET | `/api/mail/dns-check` | DKIM/SPF/DMARC-Status |

### Sicherheit

- OAuth-Tokens chmod 600
- Resend-Key in `.env`, niemals in Code
- Send-Endpoint erfordert User-Trigger-ID im Log
- HTML-Mails durch DOMPurify oder Whitelist-Tag-Filter, keine `<script>`-Pässe
- Eingehende Anhänge nicht automatisch ausführen oder öffnen

### Fehler-/Edge-Cases

- OAuth-Token ungültig → automatischer Refresh, bei Fehler 2× Retry, dann Re-Auth-Hinweis
- Resend antwortet 422 → ungültige From-Domain, DNS prüfen
- Spam-Verdacht (Bounce) → Mail im Status `bounced` markieren, Operator-Hinweis
- Rate-Limit überschritten → Backoff, Queue-Mode

### Verzeichnisstruktur

```
<root>/mail-bridge/
├── gmail_reader.py
├── resend_sender.py
├── oauth_setup.py
├── schema.sql
├── .env.example          # RESEND_API_KEY=, GMAIL_OAUTH_PATH=
└── dns/
    └── setup-guide.md
```

### Code-Snippets

Im Starter findest du Python-Snippets für Gmail-API (mit Refresh-Token-Handling), Resend-Versand, eine DNS-Check-Routine und ein FastAPI-REST-Wrapper. Dein Agent baut sie in dein Projekt ein.

---

## Teil C — Was du als Nächstes tust

1. Starter laden, deinem Agent geben
2. Sagen: "richte mir die Mail-Bridge nach diesem Blueprint ein, lesen aus `<gmail-account>`, senden über Resend aus `<deine-domain>`"
3. OAuth-Klick im Browser durchlaufen
4. DNS-Einträge bei deinem Hoster eintragen (Agent zeigt sie an)
5. Nach 5–30 Minuten DNS-Check ausführen
6. Test-Mail an dich selbst senden
7. Erste echte Mail vorsichtig an einen vertrauten Empfänger

### Lern-Checkliste

- Warum sende ich über Resend und nicht direkt über Gmail?
- Was ist DKIM und warum braucht meine Domain das?
- Wo liegt mein OAuth-Token und wie wird es erneuert?
- Wie unterscheidet sich `From` von `Reply-To`?
- Wie sehe ich, ob meine Mails im Spam landen?

Fragen: christian@denzer.ai
