Files

202 lines
7.3 KiB
Python

"""Authentication tool for the Exchange MCP server.
Provides a `login` tool that handles credential setup, browser-based SSO
login, and 2FA — all from within the MCP session. Session cookies are
encrypted at rest with the master password.
The login flow is non-blocking for 2FA:
1. First call starts browser login in the background and returns immediately
with instructions to approve 2FA on the mobile app.
2. Second call checks the background task result and loads cookies on success.
"""
import asyncio
import json
from mcp.server.fastmcp import Context
from exchange_mcp.server import mcp, AppContext
from exchange_mcp.owa_client import OWAClient
def _get_app_ctx(ctx: Context) -> AppContext:
"""Extract the AppContext from the MCP lifespan context."""
return ctx.request_context.lifespan_context
def _get_client(ctx: Context) -> OWAClient:
"""Extract the OWAClient from the MCP lifespan context."""
return _get_app_ctx(ctx).client
def _session_is_valid(client: OWAClient) -> bool:
"""Quick check: can we reach the inbox?"""
try:
client._ensure_loaded()
payload = {
"__type": "GetFolderJsonRequest:#Exchange",
"Header": {
"__type": "JsonRequestHeaders:#Exchange",
"RequestServerVersion": "Exchange2013",
},
"Body": {
"__type": "GetFolderRequest:#Exchange",
"FolderShape": {
"__type": "FolderResponseShape:#Exchange",
"BaseShape": "IdOnly",
},
"FolderIds": [
{
"__type": "DistinguishedFolderId:#Exchange",
"Id": "inbox",
}
],
},
}
data = client.request("GetFolder", payload)
items = client.extract_items(data)
return bool(items)
except Exception:
return False
@mcp.tool()
async def login(
master_password: str,
username: str = "",
password: str = "",
ctx: Context = None,
) -> str:
"""Authenticate to Exchange OWA (handles credential setup and 2FA login).
Call this tool when the session has expired or before first use.
It performs browser-based SSO login with 2FA mobile push approval.
Session cookies are encrypted at rest with the master password.
**Two-call 2FA flow**: The first call starts the browser login in the
background and returns immediately asking you to tell the user to approve
2FA on their phone. Call login again with the same master_password after
the user approves — the second call picks up the result.
Args:
master_password: Decrypts stored credentials (and cookies), or encrypts
new ones if username/password are also provided.
username: Email address. Provide together with password for first-time
credential setup (replaces `login.py --setup`).
password: Account password. Required together with username for setup.
Returns:
JSON result with success status and any error details.
"""
app_ctx = _get_app_ctx(ctx)
client = app_ctx.client
# ------------------------------------------------------------------
# If a background login task exists, check its status first
# ------------------------------------------------------------------
if app_ctx.pending_login is not None:
task = app_ctx.pending_login
if not task.done():
return json.dumps({
"status": "awaiting_2fa",
"message": "Still waiting for 2FA approval. Please approve the login in your authenticator app, then call login again.",
})
# Task finished — harvest result and clear
app_ctx.pending_login = None
try:
result = task.result()
except Exception as e:
return json.dumps({"success": False, "error": f"Background login failed: {e}"})
if result.get("success"):
from exchange_mcp.auth import encrypt_cookie_file
cookies_str = result.pop("cookies")
try:
encrypt_cookie_file(cookies_str, master_password, client.cookie_file)
client.load_cookies_from_string(cookies_str)
if _session_is_valid(client):
return json.dumps({"success": True, "message": "Logged in and session verified. Cookies encrypted."})
else:
return json.dumps({"success": True, "message": "Cookies saved but session verification failed. Try again."})
except Exception as e:
return json.dumps({"success": True, "message": f"Login succeeded but cookie handling failed: {e}"})
else:
return json.dumps(result)
# ------------------------------------------------------------------
# No pending task — normal login flow
# ------------------------------------------------------------------
# 1. Check if already authenticated (cookies already in memory)
if _session_is_valid(client):
return json.dumps({"success": True, "message": "Session is already active."})
# 2. Verify playwright is available
try:
import playwright # noqa: F401
except ImportError:
return json.dumps({
"success": False,
"error": "playwright is not installed. Run: pip install playwright && playwright install chromium",
})
# 3. Resolve credentials
from exchange_mcp.auth import (
encrypt_credentials,
decrypt_credentials,
CREDS_FILE,
decrypt_cookie_file,
encrypt_cookie_file,
perform_login,
)
if username and password:
# First-time setup: encrypt and save credentials
encrypt_credentials(username, password, master_password)
else:
# Decrypt existing credentials
if not CREDS_FILE.exists():
return json.dumps({
"success": False,
"error": "No stored credentials found. Provide username and password for first-time setup.",
})
username, password = decrypt_credentials(master_password)
if not username:
return json.dumps({
"success": False,
"error": "Invalid master password — could not decrypt credentials.",
})
# Store user email on the client for availability queries
client.user_email = username
# 4. Try restoring session from encrypted cookies on disk
cookies_str = decrypt_cookie_file(master_password, client.cookie_file)
if cookies_str:
try:
client.load_cookies_from_string(cookies_str)
if _session_is_valid(client):
return json.dumps({
"success": True,
"message": "Session restored from encrypted cookies.",
})
except Exception:
pass
# 5. Start browser login in background (non-blocking for 2FA)
app_ctx.pending_login = asyncio.create_task(
perform_login(
username=username,
password=password,
owa_url=client.owa_url,
)
)
return json.dumps({
"status": "awaiting_2fa",
"message": "Please approve the login in your 2FA authenticator app, then call login again with the same master_password.",
})