@chrischall/office-outlook-mcp 0.0.0

package/dist/tools/mail.js

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { minifiedResult, resolveView, viewParam, McpToolError } from '@chrischall/mcp-utils';
+import { compactFolder, compactMessage, fullMessage, projectCollection, } from '../view.js';
+export const VIEWS = ['compact', 'full', 'raw'];
+/**
+ * Well-known folder names the API accepts wherever a folder id is taken.
+ * All eight verified present on a live mailbox 2026-09-20.
+ */
+const WELL_KNOWN = [
+    'inbox',
+    'drafts',
+    'sentitems',
+    'deleteditems',
+    'archive',
+    'junkemail',
+    'outbox',
+    'clutter',
+];
+/** Fields worth listing. Anything not here costs bytes on every row. */
+const LIST_SELECT = 'Id,Subject,From,ToRecipients,ReceivedDateTime,IsRead,HasAttachments,BodyPreview';
+function qs(params) {
+    const parts = [];
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === '')
+            continue;
+        parts.push(`${k}=${encodeURIComponent(String(v))}`);
+    }
+    return parts.length ? `?${parts.join('&')}` : '';
+}
+/** `inbox` etc. pass through; anything else is treated as an opaque folder id. */
+function folderSegment(folder) {
+    return encodeURIComponent(folder);
+}
+export function registerMailTools(server, client) {
+    server.registerTool('outlook_list_folders', {
+        description: 'List mail folders with unread and total counts. Use this to discover folder ids before listing messages; the well-known names (' +
+            WELL_KNOWN.join(', ') +
+            ') can be used directly without a lookup.',
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            view: viewParam(VIEWS),
+            limit: z.number().int().min(1).max(200).optional().describe('Max folders (default 50)'),
+        }),
+    }, async ({ view, limit }) => {
+        const data = await client.get(`/me/mailfolders${qs({ $top: limit ?? 50 })}`);
+        if (resolveView(view, VIEWS) === 'raw')
+            return minifiedResult(data);
+        return minifiedResult(projectCollection(data, compactFolder, 'mail folder'));
+    });
+    server.registerTool('outlook_list_messages', {
+        description: "List messages in a folder, newest first. Defaults to the inbox. Use `unreadOnly` for a triage view. Bodies are NOT included — call outlook_get_message for one. Note `search` and `unreadOnly` cannot be combined (the API rejects $search with $filter); pass `search` alone to search the whole mailbox.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            view: viewParam(VIEWS),
+            folder: z
+                .string()
+                .optional()
+                .describe('Folder id or well-known name (default "inbox")'),
+            limit: z.number().int().min(1).max(100).optional().describe('Max messages (default 25)'),
+            skip: z.number().int().min(0).optional().describe('Offset for paging'),
+            unreadOnly: z.boolean().optional().describe('Only unread messages'),
+            search: z
+                .string()
+                .optional()
+                .describe('Full-text search across the whole mailbox; cannot combine with unreadOnly'),
+        }),
+    }, async ({ view, folder, limit, skip, unreadOnly, search }) => {
+        if (search !== undefined && unreadOnly === true) {
+            throw new McpToolError('`search` and `unreadOnly` cannot be combined.', {
+                hint: 'Outlook rejects $search together with $filter. Search first, then filter the results.',
+            });
+        }
+        // $search always spans the mailbox; scoping it to a folder is not supported.
+        const base = search !== undefined ? '/me/messages' : `/me/mailfolders/${folderSegment(folder ?? 'inbox')}/messages`;
+        const params = {
+            $top: limit ?? 25,
+            $skip: skip,
+            $select: LIST_SELECT,
+        };
+        if (search !== undefined) {
+            params.$search = `"${search.replace(/"/g, '')}"`;
+        }
+        else {
+            // $orderby is rejected alongside $search, so it is set only here.
+            params.$orderby = 'ReceivedDateTime desc';
+            if (unreadOnly === true)
+                params.$filter = 'IsRead eq false';
+        }
+        const data = await client.get(`${base}${qs(params)}`);
+        const v = resolveView(view, VIEWS);
+        if (v === 'raw')
+            return minifiedResult(data);
+        return minifiedResult(projectCollection(data, v === 'full' ? fullMessage : compactMessage, 'message'));
+    });
+    server.registerTool('outlook_get_message', {
+        description: 'Get one message including its body. The body is requested as plain text rather than HTML (measured ~9x smaller and far easier to read); pass view:"raw" to get Outlook\'s untouched record.',
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            view: viewParam(VIEWS),
+            id: z.string().min(1).describe('Message Id from outlook_list_messages'),
+            html: z
+                .boolean()
+                .optional()
+                .describe('Return the HTML body instead of plain text (default false)'),
+        }),
+    }, async ({ view, id, html }) => {
+        const data = await client.get(`/me/messages/${encodeURIComponent(id)}`, {
+            text: html !== true,
+        });
+        const v = resolveView(view, VIEWS);
+        if (v === 'raw')
+            return minifiedResult(data);
+        return minifiedResult(v === 'full' ? fullMessage(data) : compactMessage(data));
+    });
+    server.registerTool('outlook_list_attachments', {
+        description: "List a message's attachments (name, size, content type). Metadata only — this deliberately does not download bytes.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Message Id'),
+        }),
+    }, async ({ id }) => {
+        const data = await client.get(`/me/messages/${encodeURIComponent(id)}/attachments${qs({
+            $select: 'Id,Name,Size,ContentType',
+        })}`);
+        return minifiedResult({
+            count: data.value?.length ?? 0,
+            items: data.value ?? [],
+        });
+    });
+}

package/dist/tools/writes.js

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+import { minifiedResult } from '@chrischall/mcp-utils';
+import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+const recipientList = z
+    .array(z.string().min(3))
+    .optional()
+    .describe('Email addresses');
+function toRecipients(list) {
+    return (list ?? []).map((Address) => ({ EmailAddress: { Address } }));
+}
+/**
+ * Body shape for a message. `ContentType` is `Text` by default — an agent
+ * composing prose should not have to emit HTML, and Outlook renders text fine.
+ */
+function messageBody(subject, body, html) {
+    return {
+        Subject: subject,
+        Body: { ContentType: html === true ? 'HTML' : 'Text', Content: body },
+    };
+}
+export function registerWriteTools(server, client) {
+    server.registerTool('outlook_send_mail', {
+        description: 'Send an email from the signed-in mailbox. Requires confirm:true — without it this makes no network call and returns a preview of exactly what would be sent.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: z.object({
+            to: recipientList,
+            cc: recipientList,
+            bcc: recipientList,
+            subject: z.string().describe('Subject line'),
+            body: z.string().describe('Message body'),
+            html: z.boolean().optional().describe('Send the body as HTML (default: plain text)'),
+            saveToSentItems: z.boolean().optional().describe('Keep a copy in Sent Items (default true)'),
+            confirm: schemaConfirm,
+        }),
+    }, async ({ to, cc, bcc, subject, body, html, saveToSentItems, confirm }) => {
+        const payload = {
+            Message: {
+                ...messageBody(subject, body, html),
+                ToRecipients: toRecipients(to),
+                ...(cc?.length ? { CcRecipients: toRecipients(cc) } : {}),
+                ...(bcc?.length ? { BccRecipients: toRecipients(bcc) } : {}),
+            },
+            SaveToSentItems: saveToSentItems !== false,
+        };
+        const recipients = [...(to ?? []), ...(cc ?? []), ...(bcc ?? [])].join(', ');
+        const gate = previewUnlessConfirmed(confirm, `Send mail "${subject}" to ${recipients || '(no recipients)'}`, 'POST', '/me/sendmail', payload);
+        if (gate)
+            return gate;
+        await client.write('POST', '/me/sendmail', payload);
+        // sendmail returns 202 with an empty body; there is no id to report and
+        // no resource to re-read, so say exactly what is known.
+        return minifiedResult({ sent: true, subject, recipients: recipients || null });
+    });
+    server.registerTool('outlook_create_draft', {
+        description: 'Create a draft message in the Drafts folder without sending it. Requires confirm:true. Returns the created draft, which can be reviewed and sent from Outlook.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: z.object({
+            to: recipientList,
+            cc: recipientList,
+            subject: z.string().describe('Subject line'),
+            body: z.string().describe('Message body'),
+            html: z.boolean().optional().describe('Compose the body as HTML (default: plain text)'),
+            confirm: schemaConfirm,
+        }),
+    }, async ({ to, cc, subject, body, html, confirm }) => {
+        const payload = {
+            ...messageBody(subject, body, html),
+            ToRecipients: toRecipients(to),
+            ...(cc?.length ? { CcRecipients: toRecipients(cc) } : {}),
+        };
+        const gate = previewUnlessConfirmed(confirm, `Create draft "${subject}"`, 'POST', '/me/messages', payload);
+        if (gate)
+            return gate;
+        const created = await client.write('POST', '/me/messages', payload);
+        return minifiedResult({ created: true, Id: created?.Id, WebLink: created?.WebLink });
+    });
+    server.registerTool('outlook_mark_read', {
+        description: 'Mark a message read or unread. Requires confirm:true. The result is verified by re-reading the message — a 2xx alone is not proof it persisted.',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Message Id'),
+            isRead: z.boolean().describe('true to mark read, false to mark unread'),
+            confirm: schemaConfirm,
+        }),
+    }, async ({ id, isRead, confirm }) => {
+        const path = `/me/messages/${encodeURIComponent(id)}`;
+        const payload = { IsRead: isRead };
+        const gate = previewUnlessConfirmed(confirm, `Mark message ${id} as ${isRead ? 'read' : 'unread'}`, 'PATCH', path, payload);
+        if (gate)
+            return gate;
+        await client.write('PATCH', path, payload);
+        // Re-read rather than trust the status. IsRead is the field the write
+        // requested, so it is the field that proves it.
+        const after = await client.get(`${path}?$select=IsRead`);
+        return minifiedResult({
+            updated: after?.IsRead === isRead,
+            IsRead: after?.IsRead,
+            ...(after?.IsRead === isRead ? {} : { warning: 'Outlook accepted the write but the value did not change.' }),
+        });
+    });
+    server.registerTool('outlook_move_message', {
+        description: 'Move a message to another folder (e.g. "archive", "deleteditems", or a folder id from outlook_list_folders). Requires confirm:true. Moving assigns a NEW message id, which is returned.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Message Id'),
+            destination: z
+                .string()
+                .min(1)
+                .describe('Destination folder id or well-known name (e.g. "archive")'),
+            confirm: schemaConfirm,
+        }),
+    }, async ({ id, destination, confirm }) => {
+        const path = `/me/messages/${encodeURIComponent(id)}/move`;
+        const payload = { DestinationId: destination };
+        const gate = previewUnlessConfirmed(confirm, `Move message ${id} to ${destination}`, 'POST', path, payload);
+        if (gate)
+            return gate;
+        const moved = await client.write('POST', path, payload);
+        return minifiedResult({
+            moved: true,
+            newId: moved?.Id,
+            ParentFolderId: moved?.ParentFolderId,
+            note: 'The message has a new Id after a move; the old one no longer resolves.',
+        });
+    });
+    server.registerTool('outlook_create_event', {
+        description: 'Create a calendar event. Requires confirm:true. `timeZone` takes a WINDOWS zone name such as "Eastern Standard Time", not an IANA name.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: z.object({
+            subject: z.string().describe('Event title'),
+            start: z.string().min(1).describe('Start, ISO 8601 local time e.g. 2026-09-22T15:00:00'),
+            end: z.string().min(1).describe('End, ISO 8601 local time'),
+            timeZone: z
+                .string()
+                .optional()
+                .describe('Windows time-zone name (default "UTC")'),
+            location: z.string().optional().describe('Location display name'),
+            body: z.string().optional().describe('Event description'),
+            attendees: recipientList,
+            confirm: schemaConfirm,
+        }),
+    }, async ({ subject, start, end, timeZone, location, body, attendees, confirm }) => {
+        const tz = timeZone ?? 'UTC';
+        const payload = {
+            Subject: subject,
+            Start: { DateTime: start, TimeZone: tz },
+            End: { DateTime: end, TimeZone: tz },
+            ...(location ? { Location: { DisplayName: location } } : {}),
+            ...(body ? { Body: { ContentType: 'Text', Content: body } } : {}),
+            ...(attendees?.length
+                ? {
+                    Attendees: attendees.map((Address) => ({
+                        EmailAddress: { Address },
+                        Type: 'Required',
+                    })),
+                }
+                : {}),
+        };
+        const gate = previewUnlessConfirmed(confirm, `Create event "${subject}" ${start} to ${end} (${tz})`, 'POST', '/me/events', payload);
+        if (gate)
+            return gate;
+        const created = await client.write('POST', '/me/events', payload);
+        return minifiedResult({ created: true, Id: created?.Id, WebLink: created?.WebLink });
+    });
+}

package/dist/version.js

@@ -0,0 +1,13 @@
+/**
+ * The single source of the package version.
+ *
+ * Everything that needs a version imports from here, so release-please has one
+ * file to rewrite and there is no second marker to forget. Registered in
+ * `release-please-config.json` under `extra-files`.
+ *
+ * Note for anyone editing the comments in this file: `versionSyncTest` flags
+ * every line containing the marker string, so it must appear on the export
+ * line below and nowhere else — not even in prose.
+ */
+export const PACKAGE_NAME = 'office-outlook-mcp';
+export const VERSION = '0.0.0'; // x-release-please-version

package/dist/view.js

@@ -0,0 +1,109 @@
+/**
+ * Response projections.
+ *
+ * Outlook's default projection is ~40 fields per message including the full
+ * body, which is a great deal of context for an agent that is browsing. Every
+ * read tool therefore takes `view` and defaults to `compact`.
+ *
+ * The projections below name only fields observed on live responses
+ * (2026-09-20). Anything unrecognised falls through to the raw value rather
+ * than being dropped — a record with holes in it is indistinguishable from
+ * "there was nothing there".
+ */
+import { projectOrRaw } from '@chrischall/mcp-utils';
+function addr(r) {
+    const e = r?.EmailAddress;
+    if (!e)
+        return undefined;
+    if (e.Name && e.Address && e.Name !== e.Address)
+        return `${e.Name} <${e.Address}>`;
+    return e.Address ?? e.Name;
+}
+function addrs(list) {
+    if (!Array.isArray(list) || list.length === 0)
+        return undefined;
+    return list.map((r) => addr(r)).filter((s) => s !== undefined);
+}
+export function compactMessage(m) {
+    return pruned({
+        Id: m.Id,
+        Subject: m.Subject,
+        From: addr(m.From ?? m.Sender),
+        To: addrs(m.ToRecipients),
+        Received: m.ReceivedDateTime,
+        IsRead: m.IsRead,
+        HasAttachments: m.HasAttachments || undefined,
+        Preview: m.BodyPreview?.trim() || undefined,
+        // Present only when the caller asked for a single message; a listing
+        // projection would otherwise carry every body.
+        Body: m.Body?.Content,
+    });
+}
+export function fullMessage(m) {
+    return pruned({
+        ...compactMessage(m),
+        Cc: addrs(m.CcRecipients),
+        Sent: m.SentDateTime,
+        Importance: m.Importance,
+        IsDraft: m.IsDraft,
+        ConversationId: m.ConversationId,
+        ParentFolderId: m.ParentFolderId,
+        Categories: m.Categories?.length ? m.Categories : undefined,
+        WebLink: m.WebLink,
+    });
+}
+export function compactEvent(e) {
+    return pruned({
+        Id: e.Id,
+        Subject: e.Subject,
+        Start: e.Start?.DateTime,
+        End: e.End?.DateTime,
+        TimeZone: e.Start?.TimeZone,
+        Location: e.Location?.DisplayName || undefined,
+        Organizer: addr(e.Organizer),
+        IsAllDay: e.IsAllDay || undefined,
+        IsCancelled: e.IsCancelled || undefined,
+    });
+}
+export function fullEvent(e) {
+    return pruned({
+        ...compactEvent(e),
+        ShowAs: e.ShowAs,
+        Attendees: e.Attendees?.map((a) => pruned({ Who: addr(a), Response: a.Status?.Response })),
+        OnlineMeetingUrl: e.OnlineMeetingUrl,
+        Preview: e.BodyPreview?.trim() || undefined,
+        WebLink: e.WebLink,
+    });
+}
+export function compactFolder(f) {
+    return pruned({
+        Id: f.Id,
+        Name: f.DisplayName,
+        Unread: f.UnreadItemCount,
+        Total: f.TotalItemCount,
+    });
+}
+/** Drop `undefined` so a compact record does not carry empty keys. */
+function pruned(o) {
+    const out = {};
+    for (const [k, v] of Object.entries(o)) {
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+/**
+ * Apply a projection to an OData collection envelope, preserving paging.
+ *
+ * `projectOrRaw` hands back the raw value when the projection throws or yields
+ * nothing, so a shape we did not anticipate degrades to "everything" rather
+ * than to "nothing".
+ */
+export function projectCollection(payload, project, label) {
+    const items = Array.isArray(payload?.value) ? payload.value : [];
+    return pruned({
+        count: items.length,
+        items: items.map((item) => projectOrRaw(item, project, { label, context: 'office-outlook-mcp' })),
+        nextLink: payload?.['@odata.nextLink'],
+    });
+}

package/mint.yaml

@@ -0,0 +1,79 @@
+version: 1
+name: Outlook (Microsoft 365)
+slug: outlook
+summary: >-
+  Outlook / Microsoft 365 for Claude — read mail, folders, calendar, contacts
+  and tasks, and send mail with confirmation
+#
+# Hosting note (a comment, not user-facing summary text): this MCP mints its
+# credential through the fetchproxy BROWSER BRIDGE. It is not a full-bridge
+# server — every API request is a plain server-side fetch to
+# outlook.office.com — but the bearer token it needs can only come from a
+# signed-in Outlook tab, and tokens last only ~25h, so a hosted registration
+# that is expected to keep working needs the bridge.
+#
+# A bridged registration also needs runtime `fly-shared`, `bridge: true` and a
+# `bridgePortEnv`, which are REGISTRATION fields this manifest has no schema
+# for — set them over the control API (PUT on the registration id). The port
+# variable to name in `bridgePortEnv` is OUTLOOK_WS_PORT, declared below.
+# `state.dataDir` below is required for `bridge`.
+#
+# The alternative, for a short-lived or CI registration, is to supply
+# OUTLOOK_ACCESS_TOKEN as a principal secret and accept that it expires in
+# about a day.
+#
+# Credentials here are PER PERSON — this reads someone's work mailbox — so a
+# real deployment wants identity.perUserChild with OUTLOOK_ACCESS_TOKEN as an
+# auth field, never one operator's token shared via --secret-env.
+env:
+  - name: OUTLOOK_ACCESS_TOKEN
+    secret: true
+    required: false
+    help: >-
+      Pre-obtained Outlook bearer token. Overrides the browser bridge. Power
+      users / CI only; tokens last about 25 hours.
+  - name: OUTLOOK_DISABLE_FETCHPROXY
+    required: false
+    help: >-
+      Set to '1' to disable browser capture, requiring OUTLOOK_ACCESS_TOKEN.
+  - name: OUTLOOK_API_BASE
+    required: false
+    help: >-
+      Override the Outlook REST base URL. Defaults to
+      https://outlook.office.com/api/v2.0.
+  - name: OUTLOOK_WS_PORT
+    required: false
+    help: >-
+      fetchproxy concentrator port used for token capture. Defaults to 37149,
+      the fleet-wide shared port. Name this variable in the registration's
+      bridgePortEnv for a bridged deployment.
+  - name: OUTLOOK_CAPTURE_TIMEOUT
+    required: false
+    help: >-
+      Seconds to wait for the Outlook tab to make a request we can read a token
+      from. Defaults to 30.
+  - name: OUTLOOK_TOKEN_CACHE
+    required: false
+    help: >-
+      Set to 'false' to stop caching the captured token between runs. Defaults
+      to true.
+  - name: OUTLOOK_TOKEN_FILE
+    required: false
+    help: >-
+      Path to the cached token file. Defaults to
+      ~/.office-outlook-mcp/token.json.
+state:
+  dataDir: true
+  reason: >-
+    Caches the captured bearer token at ~/.office-outlook-mcp/token.json (0600)
+    and, for a bridged registration, holds the fetchproxy identity keypair
+    under ~/.fetchproxy/identity. Without persistence every cold start
+    re-captures from the browser — and on a scale-to-zero machine that means
+    re-prompting the user to approve pairing, constantly.
+egress:
+  # The ONLY host this server fetches. The bridge's declared domains
+  # (cloud.microsoft, office.com) are what the BROWSER reaches during token
+  # capture, not what this Node process requests, so they are deliberately not
+  # listed here.
+  allow:
+    - outlook.office.com

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@chrischall/office-outlook-mcp",
+  "version": "0.0.0",
+  "mcpName": "io.github.chrischall/office-outlook-mcp",
+  "description": "Outlook / Microsoft 365 MCP server for Claude \u2014 developed and maintained by AI (Claude Code)",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chrischall/office-outlook-mcp.git"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "outlook",
+    "office365",
+    "microsoft365",
+    "email",
+    "calendar"
+  ],
+  "type": "module",
+  "bin": {
+    "office-outlook-mcp": "dist/bundle.js"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    ".mcp.json",
+    "server.json",
+    "skills",
+    "mint.yaml"
+  ],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --external:dotenv --banner:js='import { createRequire as __createRequire } from \"module\"; const require = __createRequire(import.meta.url);' --outfile=dist/bundle.js",
+    "dev": "node dist/index.js",
+    "test": "npm run typecheck && vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "npm run typecheck && vitest run --coverage",
+    "typecheck": "tsc -p tsconfig.check.json"
+  },
+  "dependencies": {
+    "@chrischall/mcp-utils": "^2.0.0",
+    "@fetchproxy/server": "^3.0.1",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "dotenv": "^18.0.1",
+    "zod": "^4.6.2"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "^5.0.0",
+    "esbuild": "^0.28.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  }
+}

package/server.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.chrischall/office-outlook-mcp",
+  "description": "Outlook / Microsoft 365 for Claude — mail, calendar, contacts and tasks, with confirm-gated sending",
+  "repository": {
+    "url": "https://github.com/chrischall/office-outlook-mcp",
+    "source": "github"
+  },
+  "version": "0.0.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@chrischall/office-outlook-mcp",
+      "version": "0.0.0",
+      "transport": { "type": "stdio" },
+      "environmentVariables": [
+        {
+          "name": "OUTLOOK_ACCESS_TOKEN",
+          "description": "Pre-obtained Outlook bearer token. Overrides the browser bridge. Power users / CI only; tokens last about 25 hours.",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": true
+        },
+        {
+          "name": "OUTLOOK_DISABLE_FETCHPROXY",
+          "description": "Set to '1' to disable browser capture, requiring OUTLOOK_ACCESS_TOKEN.",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "OUTLOOK_API_BASE",
+          "description": "Override the Outlook REST base URL. Defaults to https://outlook.office.com/api/v2.0.",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "OUTLOOK_WS_PORT",
+          "description": "fetchproxy concentrator port used for token capture. Defaults to 37149, the fleet-wide shared port.",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "OUTLOOK_CAPTURE_TIMEOUT",
+          "description": "Seconds to wait for the Outlook tab to make a request we can read a token from. Defaults to 30.",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "OUTLOOK_TOKEN_CACHE",
+          "description": "Set to 'false' to stop caching the captured token between runs. Defaults to true.",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "OUTLOOK_TOKEN_FILE",
+          "description": "Path to the cached token file. Defaults to ~/.office-outlook-mcp/token.json.",
+          "isRequired": false,
+          "format": "string"
+        }
+      ]
+    }
+  ]
+}