Files
mcp-home/owamail/server.py
T

458 lines
17 KiB
Python

"""MCP OWA Mail Server — Zugriff auf die BBS-Arbeits-Mail (Kati) ueber die OWA-JSON-API.
Exchange 2019 (S25-EXCHANGE) mit klassischem OWA-Formular-Login unter
https://bbsbex.bbsb.org/owa/. EWS-Basic-Auth ist serverseitig deaktiviert
(401), daher Zugriff ueber den OWA-Formular-Flow mit HTTP-Session und die
interne OWA-JSON-API (/owa/service.svc?action=...).
HARTE REGEL (Sperrschutz): Genau EIN Login-Versuch pro Sitzung. Bei jedem
Login-Fehlschlag wird SOFORT abgebrochen und kein Retry unternommen, damit
Katis Arbeitspasswort nie durch automatische Wiederholungen gesperrt wird.
Tools: login (Einmal-Versuch), list_folders, search_mail, read_mail,
create_draft (Entwurf im Drafts-Ordner, KEIN Senden).
API-Muster aus https://github.com/nhype/owa-exchange-mcp (MIT, 2026):
POST /owa/service.svc?action=<Action>&EP=1&ID=-1&AC=1
mit Action-Header, X-OWA-CANARY und JSON-Payload im Exchange-JSON-Schema.
"""
import os
import sys
import contextlib
from typing import Annotated
from pydantic import Field
from mcp.server.fastmcp import FastMCP
from starlette.applications import Starlette
from starlette.routing import Mount
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
from common import get_current_user, OAUTH_ROUTES, BearerAuthMiddleware
from utils import html_to_text
from owa_client import OWASessionError, client as _owa
# Transport/Login lebt im gemeinsamen Modul (auch vom Kalender-Fetcher genutzt).
_api = _owa.api
_items = _owa.items
_header = _owa.header
_resolve_folder_id = _owa.resolve_folder_id
_owa_login = _owa.login
_get_session = _owa.session
_download_file = _owa.download_file
# Nur Katis Arbeitsmail: erlaubte Bearer-User. `mcptest` fuer lokale Tests.
ALLOWED_USERS = {"kati", "mcptest"}
def _check_user():
user = get_current_user()
if not user:
return None, "Error: not authenticated"
if user not in ALLOWED_USERS:
return None, "Zugriff verweigert: owamail ist nur fuer Katis Arbeitsmail (kati)."
return user, None
mcp = FastMCP("OWAMail", stateless_http=True,
transport_security={"enable_dns_rebinding_protection": False})
def _recipients(emails: str) -> list:
out = []
for addr in emails.split(","):
addr = addr.strip()
if addr:
out.append({
"Name": addr,
"EmailAddress": addr,
"RoutingType": "SMTP",
})
return out
def _sender_of(item: dict) -> str:
mb = item.get("From", {}).get("Mailbox", {})
if not mb:
mb = item.get("Sender", {}).get("Mailbox", {})
if not mb:
mb = item.get("Organizer", {}).get("Mailbox", {})
name = str(mb.get("Name", "") or "")
addr = str(mb.get("EmailAddress", "") or "")
return f"{name} <{addr}>" if name else addr
# ----------------------------------------------------------------------
# Tools
# ----------------------------------------------------------------------
@mcp.tool()
def login() -> str:
"""Log in to the BBS OWA mailbox. Exactly ONE login attempt; aborts on failure (no retry)."""
user, err = _check_user()
if err:
return err
return _owa_login()
@mcp.tool()
def list_folders() -> str:
"""List the top-level folders of the BBS mailbox with unread counts."""
user, err = _check_user()
if err:
return err
try:
payload = {
"__type": "FindFolderJsonRequest:#Exchange",
"Header": _header(),
"Body": {
"__type": "FindFolderRequest:#Exchange",
"FolderShape": {
"__type": "FolderResponseShape:#Exchange",
"BaseShape": "Default",
},
"ParentFolderIds": [
{"__type": "DistinguishedFolderId:#Exchange", "Id": "msgfolderroot"}
],
"Traversal": "Shallow",
"Paging": {
"__type": "IndexedPageView:#Exchange",
"BasePoint": "Beginning",
"Offset": 0,
"MaxEntriesReturned": 200,
},
},
}
data = _api("FindFolder", payload)
except OWASessionError as e:
return f"Fehler: {e}"
folders = []
for msg in _items(data):
if "RootFolder" in msg and "Folders" in msg["RootFolder"]:
for f in msg["RootFolder"]["Folders"]:
folders.append(
f"{f.get('DisplayName', '?')} "
f"(id: {f.get('FolderId', {}).get('Id', '')}, "
f"gesamt: {f.get('TotalCount', 0)}, ungelesen: {f.get('UnreadCount', 0)})"
)
return "\n".join(folders) if folders else "Keine Ordner gefunden"
def _find_items(fid, limit=50, offset=0):
"""Ein FindItem-Aufruf. Gibt (items, total, includes_last)."""
payload = {
"__type": "FindItemJsonRequest:#Exchange",
"Header": _header(),
"Body": {
"__type": "FindItemRequest:#Exchange",
"ItemShape": {
"__type": "ItemResponseShape:#Exchange",
"BaseShape": "AllProperties",
},
"ParentFolderIds": [
{"__type": "FolderId:#Exchange", "Id": fid}
],
"Traversal": "Shallow",
"Paging": {
"__type": "IndexedPageView:#Exchange",
"BasePoint": "Beginning",
"Offset": offset,
"MaxEntriesReturned": limit,
},
"SortOrder": [
{
"__type": "SortResults:#Exchange",
"Order": "Descending",
"Path": {
"__type": "PropertyUri:#Exchange",
"FieldURI": "DateTimeReceived",
},
}
],
},
}
data = _api("FindItem", payload)
items = []
total = 0
includes_last = True
for msg in _items(data):
rf = msg.get("RootFolder") or {}
items = rf.get("Items") or []
total = rf.get("TotalItemsInView", 0) or 0
if total < 0:
total = 0 # Exchange liefert -1 wenn unbekannt
includes_last = rf.get("IncludesLastItemInRange", True)
break
return items, total, includes_last
def _fmt_item(it):
subj = str(it.get("Subject", "") or "")
snd = str(_sender_of(it) or "")
return (
f"[{it.get('DateTimeReceived', it.get('DateTimeSent', ''))}] "
f"Von: {snd} | Betreff: {subj} | id: {it.get('ItemId', {}).get('Id', '')}"
)
@mcp.tool()
def search_mail(
query: Annotated[str, Field(description="Suchbegriff (Betreff/Absender)")] = "",
folder: Annotated[str, Field(description="Ordner, z.B. 'Inbox', 'Entwuerfe'. Leer fuer Posteingang.")] = "Inbox",
limit: Annotated[int, Field(description="Max. Ergebnisse pro Seite (max 50)")] = 10,
offset: Annotated[int, Field(description="Start-Index (fuer Paging; 0 = neueste)")] = 0,
scan_all: Annotated[bool, Field(description="True = alle Seiten durchblaettern bis der Suchbegriff gefunden ist (bis max 500 Mails). False = nur die aktuelle Seite.")] = False,
) -> str:
"""Search the BBS mailbox for emails (subject/sender match).
Mit scan_all=True und einem Suchbegriff werden auch alte Mails gefunden
(blättert durch den ganzen Ordner, nicht nur die ersten 50). Ohne Query
liefert der Aufruf eine Seite (limit/offset) mit Gesamtzahl und
Blätter-Hinweis.
"""
user, err = _check_user()
if err:
return err
limit = max(1, min(limit, 50))
offset = max(0, offset)
q = query.strip().lower()
try:
fid = _resolve_folder_id(folder)
if not fid:
return f"Ordner '{folder}' nicht gefunden"
if scan_all and q:
# Alle Seiten durchblaettern (deckelt bei MAX_SCAN), Treffer sammeln
results = []
off = 0
page = 50
seen = 0
max_scan = 2000
limit_reached = False
while off < max_scan:
items, total, includes_last = _find_items(fid, page, off)
for it in items:
if not isinstance(it, dict):
continue
seen += 1
subj = str(it.get("Subject", "") or "")
snd = str(_sender_of(it) or "")
if q in subj.lower() or q in snd.lower():
results.append(it)
if not items or includes_last:
break
off += len(items)
else:
limit_reached = True
lines = [_fmt_item(it) for it in results[:limit]]
if results:
head = f"{len(results)} Treffer in {seen} geprueften Mails"
elif limit_reached:
head = f"Keine Treffer in den ersten {seen} Mails (Ordner groesser; mit folder= und offset= gezielt weiterblaettern)"
else:
head = f"Keine Treffer (durchsucht: {seen} Mails)"
body = "\n".join(lines)
return head + (f"\n{body}" if body else "")
else:
# Eine Seite
items, total, includes_last = _find_items(fid, limit, offset)
lines = []
for it in items:
if not isinstance(it, dict):
continue
subj = str(it.get("Subject", "") or "")
snd = str(_sender_of(it) or "")
if q and q not in subj.lower() and q not in snd.lower():
continue
lines.append(_fmt_item(it))
more = "" if includes_last else f" | mehr vorhanden (Offset {offset+limit} fuer die naechste Seite)"
head = f"Ordner hat {total} Mails; zeige {len(lines)} (Offset {offset}){more}"
body = "\n".join(lines)
return head + (f"\n{body}" if body else "")
except OWASessionError as e:
return f"Fehler: {e}"
@mcp.tool()
def read_mail(
item_id: Annotated[str, Field(description="Mail-ID aus search_mail")],
) -> str:
"""Read a full email (body, recipients, attachments) by item ID."""
user, err = _check_user()
if err:
return err
try:
payload = {
"__type": "GetItemJsonRequest:#Exchange",
"Header": _header("V2017_08_18"),
"Body": {
"__type": "GetItemRequest:#Exchange",
"ItemShape": {
"__type": "ItemResponseShape:#Exchange",
"BaseShape": "AllProperties",
"BodyType": "HTML",
},
"ItemIds": [{"__type": "ItemId:#Exchange", "Id": item_id}],
},
}
data = _api("GetItem", payload)
except OWASessionError as e:
return f"Fehler: {e}"
for msg in _items(data):
if "Items" not in msg or not msg["Items"]:
continue
for it in msg["Items"]:
body_val = it.get("Body", {}).get("Value", "")
body_type = it.get("Body", {}).get("BodyType", "Text")
body = html_to_text(body_val) if body_type == "HTML" else body_val
to_list = ", ".join(
r.get("EmailAddress", "") for r in it.get("ToRecipients", [])
)
cc_list = ", ".join(
r.get("EmailAddress", "") for r in it.get("CcRecipients", [])
)
atts = ", ".join(
f"{a.get('Name', '?')} [id={a.get('AttachmentId', {}).get('Id', '')}]"
for a in it.get("Attachments", [])
) or "keine"
return (
f"Von: {_sender_of(it)}\n"
f"An: {to_list}\n"
f"Cc: {cc_list or '-'}\n"
f"Betreff: {it.get('Subject', '')}\n"
f"Datum: {it.get('DateTimeSent', it.get('DateTimeReceived', ''))}\n"
f"Anhaenge: {atts}\n\n"
f"{body}"
)
return "Mail nicht gefunden"
def _attachment_ids(item_id: str):
"""Holt die Anhaenge (Name + AttachmentId) einer Mail via GetItem."""
payload = {
"__type": "GetItemJsonRequest:#Exchange",
"Header": _header("V2017_08_18"),
"Body": {
"__type": "GetItemRequest:#Exchange",
"ItemShape": {
"__type": "ItemResponseShape:#Exchange",
"BaseShape": "AllProperties",
"BodyType": "HTML",
},
"ItemIds": [{"__type": "ItemId:#Exchange", "Id": item_id}],
},
}
data = _api("GetItem", payload)
for msg in _items(data):
if "Items" not in msg or not msg["Items"]:
continue
for it in msg["Items"]:
if not isinstance(it, dict):
continue
return [
{
"name": a.get("Name", "attachment"),
"attachment_id": a.get("AttachmentId", {}).get("Id", ""),
}
for a in it.get("Attachments", [])
if a.get("AttachmentId", {}).get("Id")
]
return []
@mcp.tool()
def download_attachments(
item_id: Annotated[str, Field(description="Mail-ID aus search_mail")],
target_dir: Annotated[str, Field(description="Zielverzeichnis (Host-Pfad), z.B. /mnt/ssd/LongTermStorage/openclaw-docker-20260919/ssd-openclaw/jarvis/data/workspace/owa-attachments")] = "/mnt/ssd/LongTermStorage/openclaw-docker-20260919/ssd-openclaw/jarvis/data/workspace/owa-attachments",
) -> str:
"""Download all attachments of an email to a directory on the host."""
user, err = _check_user()
if err:
return err
try:
atts = _attachment_ids(item_id)
if not atts:
return "Keine Anhaenge in dieser Mail."
os.makedirs(target_dir, exist_ok=True)
saved = []
for a in atts:
try:
content, fname, ctype = _download_file(a["attachment_id"])
fname = os.path.basename(fname) or a["name"]
path = os.path.join(target_dir, fname)
with open(path, "wb") as f:
f.write(content)
saved.append(f"{fname} ({len(content)} bytes)")
except OWASessionError as e:
return f"Fehler: {e}"
return "Heruntergeladen:\n" + "\n".join(saved) if saved else "Keine Anhaenge"
except OWASessionError as e:
return f"Fehler: {e}"
@mcp.tool()
def create_draft(
to: Annotated[str, Field(description="Empfaenger (E-Mail)")],
subject: Annotated[str, Field(description="Betreff")],
body: Annotated[str, Field(description="Mailtext")],
cc: Annotated[str, Field(description="CC (kommagetrennt, optional)")] = "",
bcc: Annotated[str, Field(description="BCC (kommagetrennt, optional)")] = "",
) -> str:
"""Create an email draft in the BBS mailbox Drafts folder. Does NOT send."""
user, err = _check_user()
if err:
return err
try:
to_rcpts = _recipients(to)
if not to_rcpts:
return "Fehler: Mindestens ein Empfaenger erforderlich"
message = {
"__type": "Message:#Exchange",
"Subject": subject,
"Body": {
"__type": "BodyContentType:#Exchange",
"BodyType": "Text",
"Value": body,
},
"ToRecipients": to_rcpts,
}
if cc:
message["CcRecipients"] = _recipients(cc)
if bcc:
message["BccRecipients"] = _recipients(bcc)
payload = {
"__type": "CreateItemJsonRequest:#Exchange",
"Header": _header("V2017_08_18"),
"Body": {
"__type": "CreateItemRequest:#Exchange",
"Items": [message],
"MessageDisposition": "SaveOnly",
},
}
data = _api("CreateItem", payload)
except OWASessionError as e:
return f"Fehler: {e}"
for msg in _items(data):
if msg.get("ResponseClass") == "Error":
return f"Fehler: {msg.get('MessageText', 'Entwurf fehlgeschlagen')}"
return f"Entwurf erstellt (An {to}, Betreff '{subject}'). Liegt im Drafts-Ordner, wurde NICHT gesendet."
def create_app():
from contextlib import asynccontextmanager
mcp_app = mcp.streamable_http_app()
@asynccontextmanager
async def lifespan(app):
async with contextlib.AsyncExitStack() as stack:
await stack.enter_async_context(mcp_app.router.lifespan_context(mcp_app))
yield
routes = list(OAUTH_ROUTES) + [Mount("/", app=mcp_app)]
app = Starlette(routes=routes, lifespan=lifespan)
app.add_middleware(BearerAuthMiddleware)
return app
if __name__ == "__main__":
import uvicorn
uvicorn.run(create_app(), host="0.0.0.0", port=5131)