outlook-teams-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yamen Sharaf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# outlook-teams-mcp
+
+A local MCP server that lets your AI assistant read and work with your **Outlook mail** and **Microsoft Teams**,
+signed in as you. No secrets and no app registration needed. Calendar isn't supported.
+
+## What it can do
+
+- **Mail:** list, search and read emails; create drafts and reply drafts (it never sends mail).
+- **Teams:** read chats and channels (including bot alerts like Datadog), search messages, find your @mentions,
+  look up people.
+- **Teams actions:** send messages (with @mentions), post and reply in channels, start chats, edit or delete your
+  own messages, share files and react.
+
+Anything that sends or changes something shows you a **preview first** and only goes through after you approve
+it. Reactions are the exception: they happen in one step.
+
+## Setup
+
+Requires Node 20+. Sign in once (this opens your browser):
+
+```bash
+npx -y outlook-teams-mcp --login
+```
+
+Then add it to your AI client (examples below). For read-only access, add the environment variable
+`OUTLOOK_TEAMS_MCP_READ_ONLY=1`; the sending tools then don't exist at all.
+
+### Claude Code
+
+```bash
+claude mcp add outlook-teams -s user -- npx -y outlook-teams-mcp
+```
+
+Read-only:
+
+```bash
+claude mcp add outlook-teams -s user -e OUTLOOK_TEAMS_MCP_READ_ONLY=1 -- npx -y outlook-teams-mcp
+```
+
+### Claude Desktop, Cursor and other `mcpServers` clients
+
+Claude Desktop: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or
+`%APPDATA%\Claude\claude_desktop_config.json` (Windows). Cursor: `~/.cursor/mcp.json`.
+
+```json
+{
+  "mcpServers": {
+    "outlook-teams": {
+      "command": "npx",
+      "args": ["-y", "outlook-teams-mcp"]
+    }
+  }
+}
+```
+
+Read-only:
+
+```json
+{
+  "mcpServers": {
+    "outlook-teams": {
+      "command": "npx",
+      "args": ["-y", "outlook-teams-mcp"],
+      "env": { "OUTLOOK_TEAMS_MCP_READ_ONLY": "1" }
+    }
+  }
+}
+```
+
+### VS Code
+
+In `.vscode/mcp.json` (one workspace) or your user `mcp.json`:
+
+```json
+{
+  "servers": {
+    "outlook-teams": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "outlook-teams-mcp"]
+    }
+  }
+}
+```
+
+> **"spawn npx ENOENT"?** Desktop apps sometimes can't find `npx`. Use the full path instead, from
+> `which npx` (e.g. `/opt/homebrew/bin/npx`).
+
+Keep the sending tools on **ask** in your client, not "always allow".
+
+## Everyday use
+
+- **Signed out?** The assistant will tell you and can reopen the sign-in page, but only when your sign-in has
+  actually expired. You can also run `npx -y outlook-teams-mcp --login` yourself.
+- **Sign out completely:** `npx -y outlook-teams-mcp --logout` removes the stored login from this machine.
+- **New machine:** sign in there too. Logins are never copied between machines.
+- **"Approval required" at sign-in?** Your organization hasn't approved some of the permissions this server asks
+  for. You can limit them with `OUTLOOK_TEAMS_MCP_SCOPES` (see [AGENTS.md](AGENTS.md)) or ask your IT team.
+
+## Running from source
+
+```bash
+git clone https://github.com/YamenSharaf/outlook-teams-mcp.git && cd outlook-teams-mcp
+npm install && npm run build
+node dist/index.js --login
+```
+
+Then use `node /path/to/outlook-teams-mcp/dist/index.js` as the command instead of `npx -y outlook-teams-mcp`.
+
+Technical details for agents and contributors are in [AGENTS.md](AGENTS.md).

package/dist/auth.js

@@ -0,0 +1,97 @@
+import { execFile } from "node:child_process";
+import { PublicClientApplication } from "@azure/msal-node";
+import { AUTHORITY, CLIENT_ID, SCOPES } from "./config.js";
+import { cachePlugin, clearCache } from "./cache.js";
+const pca = new PublicClientApplication({
+    auth: { clientId: CLIENT_ID, authority: AUTHORITY },
+    cache: { cachePlugin },
+});
+async function currentAccount() {
+    const accounts = await pca.getTokenCache().getAllAccounts();
+    const wanted = process.env.OUTLOOK_TEAMS_MCP_USERNAME?.toLowerCase();
+    if (wanted)
+        return accounts.find((a) => a.username.toLowerCase() === wanted);
+    return accounts[0];
+}
+export class NotLoggedInError extends Error {
+    constructor() {
+        super("Microsoft 365 sign-in has expired or is missing. Tell the user, and with their OK call the `login` tool " +
+            "(or they can run `outlook-teams-mcp --login` in a terminal).");
+    }
+}
+/** Silent token acquisition only (cache, then refresh token). Never opens anything. */
+export async function getAccessToken() {
+    const account = await currentAccount();
+    if (!account)
+        throw new NotLoggedInError();
+    try {
+        const result = await pca.acquireTokenSilent({ account, scopes: SCOPES });
+        return result.accessToken;
+    }
+    catch (err) {
+        const name = err.name ?? "";
+        if (name === "InteractionRequiredAuthError")
+            throw new NotLoggedInError();
+        throw err;
+    }
+}
+export async function authStatus() {
+    try {
+        await getAccessToken();
+        const account = await currentAccount();
+        return { signedIn: true, username: account?.username ?? "unknown" };
+    }
+    catch (err) {
+        return { signedIn: false, reason: err.message };
+    }
+}
+// ---------------------------------------------------------------- interactive sign-in
+const LOGIN_HOSTS = new Set(["login.microsoftonline.com", "login.microsoft.com"]);
+/** Opens a URL in the default browser, but only Microsoft sign-in URLs. */
+export function openSignInUrl(url) {
+    const host = new URL(url).hostname;
+    if (new URL(url).protocol !== "https:" || !LOGIN_HOSTS.has(host)) {
+        return Promise.reject(new Error(`Refusing to open non-Microsoft sign-in URL (${host}).`));
+    }
+    const [cmd, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
+            : ["xdg-open", [url]];
+    return new Promise((resolve, reject) => execFile(cmd, args, (err) => (err ? reject(err) : resolve())));
+}
+const SUCCESS_PAGE = "<html><body style='font-family:system-ui;margin:3em'><h2>Signed in to outlook-teams-mcp</h2><p>You can close this tab.</p></body></html>";
+const ERROR_PAGE = "<html><body style='font-family:system-ui;margin:3em'><h2>outlook-teams-mcp sign-in failed</h2><p>{{error}}: {{errorDescription}}</p></body></html>";
+/** Browser sign-in (auth code + PKCE, loopback redirect). No code to type. */
+export async function loginInteractive() {
+    const account = await currentAccount();
+    const result = await pca.acquireTokenInteractive({
+        scopes: SCOPES,
+        openBrowser: openSignInUrl,
+        successTemplate: SUCCESS_PAGE,
+        errorTemplate: ERROR_PAGE,
+        ...(account ? { loginHint: account.username } : { prompt: "select_account" }),
+    });
+    if (!result?.account)
+        throw new Error("Login did not return an account.");
+    return result.account;
+}
+/** Device-code sign-in. `onCode` receives the user-facing message (URL + code). */
+export async function loginDeviceCode(onCode) {
+    const result = await pca.acquireTokenByDeviceCode({
+        scopes: SCOPES,
+        deviceCodeCallback: (r) => onCode({ message: r.message, userCode: r.userCode, verificationUri: r.verificationUri }),
+    });
+    if (!result?.account)
+        throw new Error("Login did not return an account.");
+    return result.account;
+}
+export async function whoAmI() {
+    return currentAccount();
+}
+export async function logout() {
+    const cache = pca.getTokenCache();
+    for (const account of await cache.getAllAccounts())
+        await cache.removeAccount(account);
+    await clearCache();
+}

package/dist/cache.js

@@ -0,0 +1,107 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR, KEY_FILE, KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE, TOKEN_CACHE_FILE } from "./config.js";
+let keytarPromise;
+function loadKeytar() {
+    if (process.env.OUTLOOK_TEAMS_MCP_USE_KEYTAR === "0")
+        return Promise.resolve(null);
+    keytarPromise ??= import("keytar").then((m) => (m.default ?? m)).catch(() => null);
+    return keytarPromise;
+}
+function ensureDir() {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+function writePrivate(file, data) {
+    ensureDir();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, data, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+let cachedKey;
+async function getKey(create) {
+    if (cachedKey)
+        return cachedKey;
+    const keytar = await loadKeytar();
+    let hex = null;
+    if (keytar) {
+        try {
+            hex = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+        }
+        catch {
+            hex = null;
+        }
+    }
+    if (!hex && fs.existsSync(KEY_FILE))
+        hex = fs.readFileSync(KEY_FILE, "utf8").trim();
+    if (!hex) {
+        if (!create)
+            return undefined;
+        hex = crypto.randomBytes(32).toString("hex");
+        let stored = false;
+        if (keytar) {
+            try {
+                await keytar.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, hex);
+                stored = true;
+            }
+            catch {
+                stored = false;
+            }
+        }
+        if (!stored)
+            writePrivate(KEY_FILE, hex);
+    }
+    cachedKey = Buffer.from(hex, "hex");
+    return cachedKey;
+}
+function encrypt(key, plaintext) {
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+    const data = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return JSON.stringify({ v: 1, iv: iv.toString("base64"), tag: tag.toString("base64"), data: data.toString("base64") });
+}
+function decrypt(key, payload) {
+    const { iv, tag, data } = JSON.parse(payload);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64"));
+    decipher.setAuthTag(Buffer.from(tag, "base64"));
+    return Buffer.concat([decipher.update(Buffer.from(data, "base64")), decipher.final()]).toString("utf8");
+}
+export const cachePlugin = {
+    async beforeCacheAccess(ctx) {
+        if (!fs.existsSync(TOKEN_CACHE_FILE))
+            return;
+        const key = await getKey(false);
+        if (!key)
+            return; // key gone (e.g. keychain cleared): behave as logged out
+        try {
+            ctx.tokenCache.deserialize(decrypt(key, fs.readFileSync(TOKEN_CACHE_FILE, "utf8")));
+        }
+        catch {
+            // Corrupt or undecryptable cache: ignore; a fresh --login will overwrite it.
+        }
+    },
+    async afterCacheAccess(ctx) {
+        if (!ctx.cacheHasChanged)
+            return;
+        const key = await getKey(true);
+        writePrivate(TOKEN_CACHE_FILE, encrypt(key, ctx.tokenCache.serialize()));
+    },
+};
+export async function clearCache() {
+    fs.rmSync(TOKEN_CACHE_FILE, { force: true });
+    fs.rmSync(KEY_FILE, { force: true });
+    const keytar = await loadKeytar();
+    if (keytar) {
+        try {
+            await keytar.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+        }
+        catch {
+            // nothing stored
+        }
+    }
+    cachedKey = undefined;
+}
+export function cacheLocation() {
+    return path.resolve(TOKEN_CACHE_FILE);
+}

package/dist/config.js

@@ -0,0 +1,46 @@
+import os from "node:os";
+import path from "node:path";
+// Microsoft's first-party "Microsoft Graph Command Line Tools" public client.
+// Override with your own app registration via OUTLOOK_TEAMS_MCP_CLIENT_ID / OUTLOOK_TEAMS_MCP_TENANT_ID.
+export const CLIENT_ID = process.env.OUTLOOK_TEAMS_MCP_CLIENT_ID || "14d82eec-204b-4c2f-b7e8-296a70dab67e";
+export const TENANT_ID = process.env.OUTLOOK_TEAMS_MCP_TENANT_ID || "organizations";
+export const AUTHORITY = `https://login.microsoftonline.com/${TENANT_ID}`;
+export const GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+// Default delegated scopes. In tenants that block user consent, every requested scope must already be approved
+// for the client above, or login fails with "Approval required". Override with OUTLOOK_TEAMS_MCP_SCOPES.
+const DEFAULT_SCOPES = [
+    "User.Read",
+    "User.ReadBasic.All", // people lookup, @mentions
+    "Mail.Read",
+    "Mail.ReadWrite", // drafts only; no send/delete/move mail tools are exposed
+    "Chat.ReadWrite", // read chats, send/edit/delete own chat messages, create chats, reactions
+    "ChatMessage.Read",
+    "ChatMember.ReadWrite", // add people to group chats
+    "Team.ReadBasic.All",
+    "TeamMember.Read.All",
+    "Channel.ReadBasic.All",
+    "ChannelMessage.Read.All",
+    "ChannelMessage.Send",
+    "ChannelMessage.ReadWrite", // edit/delete own channel messages
+    "Files.ReadWrite.All", // upload files shared into chats/channels
+];
+export const SCOPES = process.env.OUTLOOK_TEAMS_MCP_SCOPES
+    ? process.env.OUTLOOK_TEAMS_MCP_SCOPES.split(/[\s,]+/).filter(Boolean)
+    : DEFAULT_SCOPES;
+function configDir() {
+    if (process.env.OUTLOOK_TEAMS_MCP_CONFIG_DIR)
+        return process.env.OUTLOOK_TEAMS_MCP_CONFIG_DIR;
+    switch (process.platform) {
+        case "darwin":
+            return path.join(os.homedir(), "Library", "Application Support", "outlook-teams-mcp");
+        case "win32":
+            return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "outlook-teams-mcp");
+        default:
+            return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "outlook-teams-mcp");
+    }
+}
+export const CONFIG_DIR = configDir();
+export const TOKEN_CACHE_FILE = path.join(CONFIG_DIR, "token-cache.enc");
+export const KEY_FILE = path.join(CONFIG_DIR, ".cache-key"); // only used when no OS credential store
+export const KEYCHAIN_SERVICE = "outlook-teams-mcp";
+export const KEYCHAIN_ACCOUNT = "token-cache-key";

package/dist/confirm.js

@@ -0,0 +1,63 @@
+import crypto from "node:crypto";
+const TOKEN_TTL_MS = 5 * 60 * 1000;
+const pending = new Map();
+function fingerprint(tool, args) {
+    const { confirmationToken: _ignored, ...rest } = args;
+    const canonical = JSON.stringify(rest, Object.keys(rest).sort());
+    return crypto.createHash("sha256").update(`${tool}\n${canonical}`).digest("hex");
+}
+function preview(req) {
+    return `${req.action}\nTo: ${req.destination}\n---\n${req.content}\n---`;
+}
+async function viaElicitation(server, req) {
+    if (!server.server.getClientCapabilities()?.elicitation)
+        return false;
+    const res = await server.server.elicitInput({
+        mode: "form",
+        message: `outlook-teams-mcp wants to write on your behalf:\n\n${preview(req)}`,
+        requestedSchema: {
+            type: "object",
+            properties: { confirm: { type: "boolean", title: `Yes, ${req.action.toLowerCase()} exactly as shown`, default: false } },
+            required: ["confirm"],
+        },
+    }, { timeout: 120_000 });
+    return res.action === "accept" && res.content?.confirm === true;
+}
+/**
+ * Runs `perform` only after explicit approval. Returns the text for the tool result.
+ * `args` are the tool's raw arguments (including any confirmationToken).
+ */
+export async function guardedWrite(server, tool, args, req, perform) {
+    if ((process.env.OUTLOOK_TEAMS_MCP_CONFIRM ?? "").toLowerCase() === "elicitation") {
+        if (!(await viaElicitation(server, req)))
+            return "NOT done — the user did not approve in the confirmation form. Do not retry unless the user asks.";
+        return `${await perform()}\n(approved by the user in the confirmation form)`;
+    }
+    const now = Date.now();
+    for (const [t, p] of pending)
+        if (p.expiresAt < now)
+            pending.delete(t);
+    const token = typeof args.confirmationToken === "string" ? args.confirmationToken : undefined;
+    const fp = fingerprint(tool, args);
+    if (!token) {
+        const newToken = crypto.randomBytes(9).toString("base64url");
+        pending.set(newToken, { fingerprint: fp, expiresAt: now + TOKEN_TTL_MS });
+        return [
+            "PREVIEW ONLY — nothing has been written yet.",
+            "",
+            preview(req),
+            "",
+            "Show this exact preview (destination and full text) to the user and ask for explicit approval.",
+            `Only if the user clearly approves (e.g. "yes, send it"), call ${tool} again with IDENTICAL arguments plus confirmationToken="${newToken}" (valid 5 minutes, single use).`,
+            "If the user wants changes, call without a token again to get a new preview. Never approve on the user's behalf.",
+        ].join("\n");
+    }
+    const entry = pending.get(token);
+    if (!entry)
+        return "NOT done — unknown or expired confirmationToken. Call again without a token to get a fresh preview for the user.";
+    if (entry.fingerprint !== fp) {
+        return "NOT done — the arguments differ from the preview the user approved. Call again without a token to get a new preview and ask the user again.";
+    }
+    pending.delete(token);
+    return `${await perform()}\n(user-approved preview executed)`;
+}

package/dist/format.js

@@ -0,0 +1,236 @@
+// Turns Graph mail/Teams payloads into compact plain text for the model.
+// Bot, Workflow and webhook posts often have an empty body and carry their content in
+// attachments (Adaptive Cards, O365 connector cards, hero cards), so those are rendered too.
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+export function htmlToText(html) {
+    if (!html)
+        return "";
+    return html
+        .replace(/<attachment[^>]*>\s*<\/attachment>/gi, "")
+        .replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, "")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<li[^>]*>/gi, "\n- ")
+        .replace(/<\/(p|div|tr|h[1-6]|blockquote|ul|ol|table)>/gi, "\n")
+        .replace(/<(td|th)[^>]*>/gi, " | ")
+        .replace(/<img[^>]*src="[^"]*\/hostedContents\/([^/"]+)\/\$value"[^>]*>/gi, "[image hostedContentId=$1]")
+        .replace(/<img[^>]*alt="([^"]*)"[^>]*>/gi, "[image: $1]")
+        .replace(/<img[^>]*>/gi, "[image]")
+        .replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_m, href, text) => {
+        const t = text.replace(/<[^>]+>/g, "").trim();
+        return t && t !== href ? `${t} (${href})` : href;
+    })
+        .replace(/<[^>]+>/g, "")
+        .replace(/&(#x?[0-9a-f]+|\w+);/gi, (m, e) => {
+        if (e[0] === "#") {
+            const code = e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return ENTITIES[e.toLowerCase()] ?? m;
+    })
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function parseContent(content) {
+    if (typeof content !== "string")
+        return content;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+}
+/** Walks an Adaptive Card element tree and collects its visible text. */
+function adaptiveToText(node, out) {
+    if (!node || typeof node !== "object")
+        return;
+    if (Array.isArray(node)) {
+        for (const n of node)
+            adaptiveToText(n, out);
+        return;
+    }
+    switch (node.type) {
+        case "TextBlock":
+            if (node.text)
+                out.push(String(node.text));
+            break;
+        case "RichTextBlock":
+            out.push((node.inlines ?? []).map((i) => (typeof i === "string" ? i : (i.text ?? ""))).join(""));
+            break;
+        case "FactSet":
+            for (const f of node.facts ?? [])
+                out.push(`${String(f.title ?? "").replace(/:\s*$/, "")}: ${f.value ?? ""}`);
+            break;
+        case "Image":
+            if (node.altText)
+                out.push(`[image: ${node.altText}]`);
+            break;
+        case "Action.OpenUrl":
+            out.push(`[${node.title ?? "link"}](${node.url})`);
+            break;
+        case "Action.ShowCard":
+            if (node.title)
+                out.push(`[${node.title}]`);
+            adaptiveToText(node.card, out);
+            return;
+        case "Action.Submit":
+        case "Action.Execute":
+            if (node.title)
+                out.push(`[button: ${node.title}]`);
+            break;
+        case "Table":
+            for (const row of node.rows ?? []) {
+                const cells = (row.cells ?? []).map((c) => {
+                    const parts = [];
+                    adaptiveToText(c.items, parts);
+                    return parts.join(" ");
+                });
+                out.push(cells.join(" | "));
+            }
+            return;
+    }
+    for (const key of ["body", "items", "columns", "actions", "inlines"]) {
+        if (key === "inlines" && node.type === "RichTextBlock")
+            continue;
+        if (node[key])
+            adaptiveToText(node[key], out);
+    }
+    if (node.selectAction?.url)
+        out.push(`(${node.selectAction.url})`);
+}
+function connectorToText(card) {
+    const out = [];
+    if (card.title)
+        out.push(String(card.title));
+    if (card.summary && card.summary !== card.title)
+        out.push(String(card.summary));
+    if (card.text)
+        out.push(htmlToText(card.text));
+    for (const s of card.sections ?? []) {
+        for (const k of ["activityTitle", "activitySubtitle", "activityText", "title", "text"]) {
+            if (s[k])
+                out.push(htmlToText(String(s[k])));
+        }
+        for (const f of s.facts ?? [])
+            out.push(`${f.name ?? ""}: ${htmlToText(String(f.value ?? ""))}`);
+    }
+    for (const a of card.potentialAction ?? []) {
+        const uri = a.targets?.[0]?.uri ?? a.target?.[0];
+        out.push(uri ? `[${a.name}](${uri})` : `[${a.name}]`);
+    }
+    return out;
+}
+function heroToText(card) {
+    const out = [];
+    for (const k of ["title", "subtitle", "text"])
+        if (card[k])
+            out.push(htmlToText(String(card[k])));
+    for (const b of card.buttons ?? [])
+        out.push(b.value ? `[${b.title}](${b.value})` : `[${b.title}]`);
+    return out;
+}
+export function attachmentsToText(attachments) {
+    const out = [];
+    for (const a of attachments ?? []) {
+        const ct = String(a.contentType ?? "");
+        const content = parseContent(a.content);
+        if (ct === "application/vnd.microsoft.card.adaptive") {
+            const parts = [];
+            adaptiveToText(content, parts);
+            if (parts.length)
+                out.push(`[card]\n${parts.filter(Boolean).join("\n")}`);
+        }
+        else if (ct === "application/vnd.microsoft.teams.card.o365connector") {
+            out.push(`[connector card]\n${connectorToText(content).filter(Boolean).join("\n")}`);
+        }
+        else if (ct === "application/vnd.microsoft.card.hero" || ct === "application/vnd.microsoft.card.thumbnail") {
+            out.push(`[card]\n${heroToText(content).filter(Boolean).join("\n")}`);
+        }
+        else if (ct === "messageReference") {
+            const preview = content?.messagePreview ?? "";
+            const who = content?.messageSender?.user?.displayName ?? content?.messageSender?.application?.displayName ?? "";
+            out.push(`[quoting ${who}: ${String(preview).slice(0, 200)}]`);
+        }
+        else if (ct === "reference") {
+            out.push(`[file: ${a.name ?? "attachment"}${a.contentUrl ? ` ${a.contentUrl}` : ""}]`);
+        }
+        else if (a.name || a.contentUrl) {
+            out.push(`[attachment: ${a.name ?? ct}${a.contentUrl ? ` ${a.contentUrl}` : ""}]`);
+        }
+    }
+    return out;
+}
+function sender(from) {
+    if (!from)
+        return "system";
+    if (from.user)
+        return from.user.displayName ?? from.user.id ?? "unknown user";
+    if (from.application)
+        return `${from.application.displayName ?? "app"} (bot)`;
+    if (from.device)
+        return `${from.device.displayName ?? "device"} (device)`;
+    return "unknown";
+}
+export function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, max)}\n…[truncated ${text.length - max} chars]` : text;
+}
+export function formatTeamsMessage(m, maxChars = 4000) {
+    const head = [`[${m.createdDateTime}] ${sender(m.from)}`, `id=${m.id}`];
+    if (m.replyToId)
+        head.push(`replyTo=${m.replyToId}`);
+    if (m.lastEditedDateTime)
+        head.push("edited");
+    if (m.deletedDateTime)
+        return `${head.join(" · ")}\n(deleted)`;
+    const parts = [];
+    if (m.subject)
+        parts.push(`Subject: ${m.subject}`);
+    if (m.messageType === "systemEventMessage") {
+        parts.push(`(system event: ${m.eventDetail?.["@odata.type"]?.replace("#microsoft.graph.", "") ?? "unknown"})`);
+    }
+    const body = m.body?.contentType === "html" ? htmlToText(m.body?.content) : String(m.body?.content ?? "").trim();
+    if (body)
+        parts.push(body);
+    parts.push(...attachmentsToText(m.attachments));
+    const reactions = (m.reactions ?? []).map((r) => r.displayName ?? r.reactionType).filter(Boolean);
+    if (reactions.length)
+        parts.push(`(reactions: ${reactions.join(" ")})`);
+    return `${head.join(" · ")}\n${truncate(parts.join("\n") || "(empty)", maxChars)}`;
+}
+function addr(r) {
+    const e = r?.emailAddress;
+    if (!e)
+        return "";
+    return e.name && e.name !== e.address ? `${e.name} <${e.address}>` : (e.address ?? "");
+}
+export function formatMailSummary(m) {
+    const flags = [m.isRead === false ? "UNREAD" : "", m.hasAttachments ? "📎" : "", m.importance === "high" ? "!" : ""]
+        .filter(Boolean)
+        .join(" ");
+    return [
+        `[${m.receivedDateTime}] ${flags ? `${flags} ` : ""}${m.subject ?? "(no subject)"}`,
+        `  from: ${addr(m.from)}`,
+        `  id: ${m.id}`,
+        m.bodyPreview ? `  ${String(m.bodyPreview).replace(/\s+/g, " ").slice(0, 200)}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function formatMailFull(m, maxChars) {
+    const body = m.body?.contentType === "html" ? htmlToText(m.body?.content) : String(m.body?.content ?? "");
+    const lines = [
+        `Subject: ${m.subject ?? "(no subject)"}`,
+        `From: ${addr(m.from)}`,
+        `To: ${(m.toRecipients ?? []).map(addr).join(", ")}`,
+        m.ccRecipients?.length ? `Cc: ${m.ccRecipients.map(addr).join(", ")}` : "",
+        `Received: ${m.receivedDateTime}`,
+        `Id: ${m.id}`,
+        m.conversationId ? `ConversationId: ${m.conversationId}` : "",
+        m.webLink ? `Link: ${m.webLink}` : "",
+    ].filter(Boolean);
+    if (m.attachments?.length) {
+        lines.push(`Attachments: ${m.attachments.map((a) => `${a.name} (${a.contentType}, ${a.size} bytes)`).join("; ")}`);
+    }
+    return `${lines.join("\n")}\n\n${truncate(body, maxChars)}`;
+}