"""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=&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)