w

.gitignore

@@ -11,4 +11,3 @@
 .yarn
 node_modules
 config.json
-data/

SKILL.md

@@ -1,173 +0,0 @@
----
-name: exchange-mcp
-description: >-
-  Use this skill when the user talks about
-  email, calendar, contacts, Exchange, EWS, corporate mail,
-  or scheduling meetings.
----
-
-# exchange-mcp — MCP server for Microsoft Exchange
-
-This MCP server provides access to **Microsoft Exchange Server** via **Exchange
-Web Services (EWS)** with NTLM authentication. Supports email, calendar,
-contacts, and free/busy scheduling.
-
-**Use this server when the user talks about:**
-
-- Email, inbox, sent items, drafts
-- Calendar, events, meetings, availability
-- Contacts, people, colleagues, employees
-- Attachments, files in emails
-- Exchange, EWS, corporate mail
-
-**Does not support:** Microsoft 365 / Exchange Online (OAuth), IMAP/POP3/SMTP,
-Gmail, Outlook.com.
-
----
-
-## Tools
-
-### Auth
-
-#### `login`
-
-Authenticate to Exchange EWS via NTLM.
-
-| Parameter   | Type   | Required | Description                                      |
-| ----------- | ------ | -------- | ------------------------------------------------ |
-| `serverUrl` | string | yes      | EWS server URL (e.g. `https://mail.example.com`) |
-| `email`     | string | yes      | Email address                                    |
-| `username`  | string | yes      | NTLM username                                    |
-| `password`  | string | yes      | NTLM password                                    |
-| `domain`    | string | no       | NTLM domain (default: `corp`)                    |
-
-#### `check_session`
-
-Check if the current session is authenticated. No parameters. Returns
-`{authenticated, email, serverUrl}`.
-
-#### `logout`
-
-Clear stored credentials. No parameters.
-
----
-
-### Email
-
-#### `get_emails`
-
-Get emails from a folder. Supports optional text search via
-`query`/`queryScope`.
-
-| Parameter     | Type    | Default   | Description                                                                         |
-| ------------- | ------- | --------- | ----------------------------------------------------------------------------------- |
-| `folder`      | string  | `"Inbox"` | Folder name (Inbox, Sent, Drafts, Deleted, Junk, or custom; supports Russian names) |
-| `limit`       | number  | `10`      | Max emails (max 50; max 500 if `idsOnly=true`)                                      |
-| `offset`      | number  | `0`       | Pagination offset                                                                   |
-| `includeBody` | boolean | `false`   | If `true`, fetches full email body                                                  |
-| `unreadOnly`  | boolean | `false`   | Only unread emails                                                                  |
-| `idsOnly`     | boolean | `false`   | Return only IDs + dates + subjects (faster, higher limit)                           |
-| `query`       | string  | —         | Text to search for within the folder                                                |
-| `queryScope`  | enum    | `"all"`   | Scope: `all`, `subject`, `body`, `from` (only when `query` is set)                  |
-
-#### `get_email`
-
-Get a single email with full body and details.
-
-| Parameter | Type   | Required | Description                  |
-| --------- | ------ | -------- | ---------------------------- |
-| `itemId`  | string | yes      | Exchange ItemId of the email |
-
-#### `mark_email_read`
-
-Mark emails as read or unread.
-
-| Parameter | Type     | Default | Description                     |
-| --------- | -------- | ------- | ------------------------------- |
-| `itemIds` | string[] | —       | List of Exchange ItemIds        |
-| `isRead`  | boolean  | `true`  | `true` = read, `false` = unread |
-
-#### `download_attachments`
-
-Download all file attachments from an email to disk.
-
-| Parameter      | Type   | Default              | Description     |
-| -------------- | ------ | -------------------- | --------------- |
-| `itemId`       | string | —                    | Exchange ItemId |
-| `targetFolder` | string | `"/tmp/attachments"` | Local folder    |
-
----
-
-### Folders
-
-#### `get_folders`
-
-List mailbox folders.
-
-| Parameter        | Type    | Default           | Description                                                       |
-| ---------------- | ------- | ----------------- | ----------------------------------------------------------------- |
-| `parentFolderId` | string  | `"msgfolderroot"` | Parent folder (supports distinguished names: `inbox`, `calendar`) |
-| `recursive`      | boolean | `false`           | Recursively traverse subfolders                                   |
-
----
-
-### Calendar
-
-#### `get_calendar_events`
-
-Get calendar events within a date range.
-
-| Parameter     | Type    | Required | Description                               |
-| ------------- | ------- | -------- | ----------------------------------------- |
-| `startDate`   | string  | yes      | Start (`YYYY-MM-DD`)                      |
-| `endDate`     | string  | yes      | End (`YYYY-MM-DD`)                        |
-| `includeBody` | boolean | `false`  | Full details (organizer, attendees, body) |
-
-#### `download_event_attachments`
-
-Download attachments from a calendar event. Same parameters as
-`download_attachments`.
-
----
-
-### Availability
-
-#### `find_free_time`
-
-Find free time slots in your calendar.
-
-| Parameter         | Type   | Default     | Description                |
-| ----------------- | ------ | ----------- | -------------------------- |
-| `startDate`       | string | —           | Start (`YYYY-MM-DD`)       |
-| `endDate`         | string | = startDate | End                        |
-| `durationMinutes` | number | `30`        | Minimum slot duration      |
-| `startHour`       | number | `9`         | Work day start hour (0-23) |
-| `endHour`         | number | `18`        | Work day end hour (0-23)   |
-
-#### `find_meeting_time`
-
-Find common free time for multiple people.
-
-| Parameter         | Type   | Default     | Description                       |
-| ----------------- | ------ | ----------- | --------------------------------- |
-| `emails`          | string | —           | Attendee emails (comma-separated) |
-| `startDate`       | string | —           | Start                             |
-| `endDate`         | string | = startDate | End                               |
-| `durationMinutes` | number | `30`        | Minimum slot duration             |
-| `startHour`       | number | `9`         | Work day start hour               |
-| `endHour`         | number | `18`        | Work day end hour                 |
-
----
-
-### People
-
-#### `find_person`
-
-Search for people in the corporate directory (Active Directory).
-
-| Parameter | Type   | Required | Description             |
-| --------- | ------ | -------- | ----------------------- |
-| `query`   | string | yes      | Name, email, or keyword |
-
-Returns: name, email, job title, department, company, office, phone, manager,
-direct reports.

dockerfile

@@ -1,5 +0,0 @@
-FROM node:26-slim
-WORKDIR /app
-COPY . .
-RUN npm install
-CMD ["npm", "start"]

dprint.json

@@ -5,18 +5,14 @@
     "module.sortImportDeclarations": "caseInsensitive",
     "module.sortExportDeclarations": "caseInsensitive"
   },
-  "markdown": {
-    "lineWidth": 80,
-    "textWrap": "always"
-  },
   "excludes": [
     "**/.git",
     "**/.target"
   ],
   "plugins": [
-    "https://plugins.dprint.dev/typescript-0.96.1.wasm",
+    "https://plugins.dprint.dev/typescript-0.91.1.wasm",
-    "https://plugins.dprint.dev/json-0.23.0.wasm",
+    "https://plugins.dprint.dev/json-0.17.4.wasm",
-    "https://plugins.dprint.dev/markdown-0.22.1.wasm",
+    "https://plugins.dprint.dev/markdown-0.15.3.wasm",
-    "https://plugins.dprint.dev/dockerfile-0.4.1.wasm"
+    "https://plugins.dprint.dev/dockerfile-0.3.0.wasm"
   ]
 }

ews_client.ts

@@ -3,34 +3,9 @@ import fs from "node:fs";
 import https from "node:https";
 import { createRequire } from "node:module";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import type { Email } from "./types/email.ts";
+import type { Email, Folder, LoginConfig } from "./models.ts";
-import type { Folder } from "./types/folder.ts";
-import type { LoginConfig } from "./types/login_config.ts";
-
-let inMemoryPassword: string | null = null;
-let dataDir: string = "./data";
-
-export function initDataDir(dir: string): void {
-  dataDir = path.resolve(dir);
-  fs.mkdirSync(dataDir, { recursive: true });
-}
-
-export function setPassword(password: string): void {
-  inMemoryPassword = password;
-}
-
-export function getPassword(): string | null {
-  return inMemoryPassword;
-}
-
-export function hasPassword(): boolean {
-  return inMemoryPassword !== null;
-}
-
-export function clearPassword(): void {
-  inMemoryPassword = null;
-}
 
 const ntlm: any = createRequire(import.meta.url)("httpntlm");
 const postAsync = promisify(ntlm.post.bind(ntlm));
@@ -79,7 +54,8 @@ ${body}
 }
 
 function configFilePath(): string {
-  return path.join(dataDir, "config.json");
+  const dir = path.dirname(fileURLToPath(import.meta.url));
+  return path.join(dir, "config.json");
 }
 
 export function loadConfig(): LoginConfig {
@@ -100,38 +76,27 @@ export function clearConfig(): void {
   if (fs.existsSync(filePath)) {
     fs.unlinkSync(filePath);
   }
-  clearPassword();
 }
 
 export class EwsClient {
   private config: LoginConfig;
   private ewsUrl: string;
 
-  constructor(config: LoginConfig, password?: string) {
+  constructor(config: LoginConfig) {
     this.config = config;
     this.ewsUrl = `${config.serverUrl.replace(/\/+$/, "")}/EWS/Exchange.asmx`;
-
-    if (password) {
-      setPassword(password);
-    }
   }
 
   private get domain(): string {
     return this.config.domain ?? "corp";
   }
 
-  private get password(): string {
-    const pw = getPassword();
-    if (!pw) throw new Error("Not logged in. Password not found in memory.");
-    return pw;
-  }
-
   private async soapRequest(body: string, soapAction: string): Promise<any> {
     const res = await postAsync({
       url: this.ewsUrl,
       username: this.config.username,
       domain: this.domain,
-      password: this.password,
+      password: this.config.password,
       agent: AGENT,
       headers: {
         "Content-Type": "text/xml; charset=utf-8",
@@ -250,13 +215,6 @@ export class EwsClient {
       traversal = "Shallow",
     } = options;
 
-    const isDistinguished =
-      DISTINGUISHED_FOLDERS[folderId.toLowerCase()] !== undefined;
-
-    const folderIdXml = isDistinguished
-      ? `<t:DistinguishedFolderId Id="${folderId}"/>`
-      : `<t:FolderId Id="${folderId}"/>`;
-
     const soap = buildSoapEnvelope(`\
     <m:FindItem Traversal="${traversal}">
       <m:ItemShape>
@@ -264,7 +222,7 @@ export class EwsClient {
       </m:ItemShape>
       <m:IndexedPageItemView MaxEntriesReturned="${limit}" Offset="${offset}" BasePoint="Beginning"/>
       <m:ParentFolderIds>
-        ${folderIdXml}
+        <t:FolderId Id="${folderId}"/>
       </m:ParentFolderIds>
       <m:SortOrder>
         <t:FieldOrder Order="Descending">
@@ -530,200 +488,4 @@ ${restriction}
     text = text.replace(/[ \t]+/g, " ");
     return text.trim();
   }
-
-  // ── UpdateItem (for marking read/unread, etc.) ──────────────────────────
-
-  async updateItems(
-    itemIds: string[],
-    updates: { fieldUri: string; value: string | boolean }[],
-  ): Promise<any[]> {
-    const propName = (fieldUri: string): string => {
-      const parts = fieldUri.split(":");
-      return parts[parts.length - 1];
-    };
-
-    const changesXml = itemIds.map((id) => {
-      const updatesXml = updates.map((u) => {
-        const val = typeof u.value === "boolean"
-          ? (u.value ? "true" : "false")
-          : u.value;
-        return `\
-            <t:SetItemField>
-              <t:FieldURI FieldURI="${u.fieldUri}"/>
-              <t:Message>
-                <t:${propName(u.fieldUri)}>${String(val)}</t:${
-          propName(u.fieldUri)
-        }>
-              </t:Message>
-            </t:SetItemField>`;
-      }).join("\n");
-
-      return `\
-        <t:ItemChange>
-          <t:ItemId Id="${id}"/>
-          <t:Updates>
-${updatesXml}
-          </t:Updates>
-        </t:ItemChange>`;
-    }).join("\n");
-
-    const soap = buildSoapEnvelope(`\
-    <m:UpdateItem MessageDisposition="SaveOnly" ConflictResolution="AutoResolve">
-      <m:ItemChanges>
-${changesXml}
-      </m:ItemChanges>
-    </m:UpdateItem>`);
-
-    const data = await this.soapRequest(
-      soap,
-      "http://schemas.microsoft.com/exchange/services/2006/messages/UpdateItem",
-    );
-
-    return this.extractResponseMessages(data);
-  }
-
-  // ── GetAttachment ───────────────────────────────────────────────────────
-
-  async getAttachment(
-    attachmentId: string,
-  ): Promise<{ content: Buffer; name: string; contentType: string }> {
-    const soap = buildSoapEnvelope(`\
-    <m:GetAttachment>
-      <m:AttachmentIds>
-        <t:AttachmentId Id="${attachmentId}"/>
-      </m:AttachmentIds>
-    </m:GetAttachment>`);
-
-    const data = await this.soapRequest(
-      soap,
-      "http://schemas.microsoft.com/exchange/services/2006/messages/GetAttachment",
-    );
-
-    for (const msg of this.extractResponseMessages(data)) {
-      const attachments = msg?.Attachments?.FileAttachment;
-      if (!attachments) continue;
-      const list = Array.isArray(attachments) ? attachments : [attachments];
-      for (const a of list) {
-        const contentBase64 = a.Content ?? "";
-        const content = Buffer.from(contentBase64, "base64");
-        return {
-          content,
-          name: a.Name ?? "attachment",
-          contentType: a.ContentType ?? "application/octet-stream",
-        };
-      }
-    }
-
-    throw new Error(`Attachment '${attachmentId}' not found`);
-  }
-
-  // ── FindItem with CalendarView ──────────────────────────────────────────
-
-  async findCalendarItems(
-    folderId: string,
-    startDate: string,
-    endDate: string,
-  ): Promise<any[]> {
-    const soap = buildSoapEnvelope(`\
-    <m:FindItem Traversal="Shallow">
-      <m:ItemShape>
-        <t:BaseShape>AllProperties</t:BaseShape>
-        <t:BodyType>HTML</t:BodyType>
-      </m:ItemShape>
-      <m:ParentFolderIds>
-        <t:FolderId Id="${folderId}"/>
-      </m:ParentFolderIds>
-      <m:CalendarView MaxEntriesReturned="200" StartDate="${startDate}" EndDate="${endDate}"/>
-    </m:FindItem>`);
-
-    const data = await this.soapRequest(
-      soap,
-      "http://schemas.microsoft.com/exchange/services/2006/messages/FindItem",
-    );
-
-    for (const msg of this.extractResponseMessages(data)) {
-      const items = msg?.RootFolder?.Items?.CalendarItem;
-      if (!items) continue;
-      return Array.isArray(items) ? items : [items];
-    }
-
-    return [];
-  }
-
-  // ── GetUserAvailability ─────────────────────────────────────────────────
-
-  async getUserAvailability(
-    emails: string[],
-    startDate: string,
-    endDate: string,
-    requestedView: string = "DetailedMerged",
-  ): Promise<any> {
-    const mailboxDataXml = emails.map((email) =>
-      `\
-        <t:MailboxData>
-          <t:Email>
-            <t:Address>${
-        email.replace(/&/g, "&amp;").replace(/</g, "&lt;")
-      }</t:Address>
-          </t:Email>
-          <t:AttendeeType>Required</t:AttendeeType>
-        </t:MailboxData>`
-    ).join("\n");
-
-    const soap = `<?xml version="1.0" encoding="utf-8"?>
-<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
-  xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages"
-  xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types">
-  <s:Body>
-    <m:GetUserAvailabilityRequest>
-      <m:MailboxDataArray>
-${mailboxDataXml}
-      </m:MailboxDataArray>
-      <m:FreeBusyViewOptions>
-        <t:TimeWindow>
-          <t:StartTime>${startDate}T00:00:00</t:StartTime>
-          <t:EndTime>${endDate}T23:59:59</t:EndTime>
-        </t:TimeWindow>
-        <t:MergedFreeBusyIntervalInMinutes>30</t:MergedFreeBusyIntervalInMinutes>
-        <t:RequestedView>${requestedView}</t:RequestedView>
-      </m:FreeBusyViewOptions>
-    </m:GetUserAvailabilityRequest>
-  </s:Body>
-</s:Envelope>`;
-
-    const data = await this.soapRequest(
-      soap,
-      "http://schemas.microsoft.com/exchange/services/2006/messages/GetUserAvailability",
-    );
-
-    return data;
-  }
-
-  // ── ResolveNames (directory search) ─────────────────────────────────────
-
-  async resolveNames(
-    query: string,
-    fullContact: boolean = true,
-  ): Promise<any[]> {
-    const soap = buildSoapEnvelope(`\
-    <m:ResolveNames ReturnFullContactData="${fullContact}" SearchScope="ActiveDirectoryContacts">
-      <m:UnresolvedEntry>${
-      query.replace(/&/g, "&amp;").replace(/</g, "&lt;")
-    }</m:UnresolvedEntry>
-    </m:ResolveNames>`);
-
-    const data = await this.soapRequest(
-      soap,
-      "http://schemas.microsoft.com/exchange/services/2006/messages/ResolveNames",
-    );
-
-    for (const msg of this.extractResponseMessages(data)) {
-      const resolutions = msg?.ResolutionSet?.Resolution;
-      if (resolutions) {
-        return Array.isArray(resolutions) ? resolutions : [resolutions];
-      }
-    }
-
-    return [];
-  }
 }

main.ts

@@ -4,13 +4,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { Command } from "commander";
 import crypto from "node:crypto";
 import http from "node:http";
-import { initDataDir } from "./ews_client.ts";
 import { registerAuthTools } from "./tools/auth.ts";
-import { registerAvailabilityTools } from "./tools/availability.ts";
-import { registerCalendarTools } from "./tools/calendar.ts";
 import { registerEmailTools } from "./tools/email.ts";
 import { registerFolderTools } from "./tools/folders.ts";
-import { registerPeopleTools } from "./tools/people.ts";
 
 const program = new Command()
   .name("exchange-mcp")
@@ -21,14 +17,11 @@ const program = new Command()
     "SHA-256 hash of bearer token for HTTP transport auth",
   )
   .option("--host <host>", "HTTP host", "127.0.0.1")
-  .option("--port <port>", "HTTP port", "8000")
+  .option("--port <port>", "HTTP port", "8000");
-  .option("--data-dir <path>", "Data directory for config.json", "./data");
 
 program.parse(process.argv);
 const options = program.opts();
 
-initDataDir(options.dataDir);
-
 function buildServer(): McpServer {
   const server = new McpServer({
     name: "exchange-mcp",
@@ -38,9 +31,6 @@ function buildServer(): McpServer {
   registerAuthTools(server);
   registerEmailTools(server);
   registerFolderTools(server);
-  registerCalendarTools(server);
-  registerAvailabilityTools(server);
-  registerPeopleTools(server);
 
   return server;
 }

models.ts

@@ -0,0 +1,103 @@
+export interface LoginConfig {
+  serverUrl: string;
+  email: string;
+  username: string;
+  password: string;
+  domain?: string;
+}
+
+export interface Email {
+  subject: string;
+  from: string;
+  fromName: string;
+  date: string;
+  isRead: boolean;
+  hasAttachments: boolean;
+  hasLinks: boolean;
+  itemId: string;
+  size: number;
+  isMeeting: boolean;
+  itemType: string;
+  to: string[];
+  cc: string[];
+  body: string;
+  bodyType: string;
+  attachments: Attachment[];
+  preview: string;
+  location?: string;
+  start?: string;
+  end?: string;
+  requiredAttendees?: string[];
+  optionalAttendees?: string[];
+}
+
+export interface Attachment {
+  name: string;
+  size: number;
+  contentType: string;
+  attachmentId: string;
+  isInline: boolean;
+}
+
+export interface Folder {
+  name: string;
+  id: string;
+  totalCount: number;
+  unreadCount: number;
+  childFolderCount: number;
+}
+
+export interface Person {
+  name: string;
+  email: string;
+  mailboxType: string;
+  firstName: string;
+  lastName: string;
+  jobTitle: string;
+  department: string;
+  company: string;
+  office: string;
+  alias: string;
+  manager: string;
+  managerEmail: string;
+  phones: Record<string, string>;
+  address: string;
+  directReports: Array<{ name: string; email: string }>;
+}
+
+export interface CalendarEvent {
+  subject: string;
+  start: string;
+  end: string;
+  location: string;
+  isAllDay: boolean;
+  isCancelled: boolean;
+  isMeeting: boolean;
+  isRecurring: boolean;
+  organizer: string;
+  organizerEmail: string;
+  myResponse: string;
+  itemId: string;
+  body: string;
+  requiredAttendees: string[];
+  optionalAttendees: string[];
+}
+
+export interface FreeSlot {
+  date: string;
+  start: string;
+  end: string;
+  durationMinutes: number;
+}
+
+export interface MeetingResult {
+  success: boolean;
+  subject: string;
+  date: string;
+  startTime: string;
+  endTime: string;
+  location: string;
+  requiredAttendees: string[];
+  optionalAttendees: string[];
+  error: string;
+}

tools/auth.ts

@@ -3,10 +3,8 @@ import { z } from "zod/v4";
 import {
   clearConfig,
   EwsClient,
-  hasPassword,
   loadConfig,
   saveConfig,
-  setPassword,
 } from "../ews_client.ts";
 
 export function registerAuthTools(server: McpServer): void {
@@ -30,10 +28,11 @@ export function registerAuthTools(server: McpServer): void {
           serverUrl: serverUrl.replace(/\/+$/, ""),
           email,
           username,
+          password,
           domain: domain ?? "corp",
         };
 
-        const client = new EwsClient(config, password);
+        const client = new EwsClient(config);
         const result = await client.verifyConnection();
 
         if (!result.ok) {
@@ -81,17 +80,6 @@ export function registerAuthTools(server: McpServer): void {
     },
     async () => {
       try {
-        if (!hasPassword()) {
-          return {
-            content: [{
-              type: "text" as const,
-              text: JSON.stringify({
-                authenticated: false,
-                error: "Not logged in. Password not found in memory.",
-              }),
-            }],
-          };
-        }
         const config = loadConfig();
         const client = new EwsClient(config);
         const result = await client.verifyConnection();

tools/availability.ts

@@ -1,331 +0,0 @@
-import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod/v4";
-import { EwsClient, loadConfig } from "../ews_client.ts";
-
-export function registerAvailabilityTools(server: McpServer): void {
-  server.registerTool(
-    "find_free_time",
-    {
-      description: "Find free time slots in your own calendar",
-      inputSchema: z.object({
-        startDate: z.string().describe("Start date in YYYY-MM-DD format"),
-        endDate: z.string().optional().describe(
-          "End date in YYYY-MM-DD format (defaults to startDate)",
-        ),
-        durationMinutes: z.number().default(30).describe(
-          "Minimum slot duration in minutes (default 30)",
-        ),
-        startHour: z.number().default(9).describe(
-          "Working day start hour (0-23, default 9)",
-        ),
-        endHour: z.number().default(18).describe(
-          "Working day end hour (0-23, default 18)",
-        ),
-      }),
-    },
-    async ({ startDate, endDate, durationMinutes, startHour, endHour }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const config = loadConfig();
-        const ed = endDate || startDate;
-
-        const data = await client.getUserAvailability(
-          [config.email],
-          startDate,
-          ed,
-        );
-
-        const body = data?.Envelope?.Body?.GetUserAvailabilityResponse
-          ?? data?.Envelope?.Body ?? {};
-        const freeBusyArray = body?.FreeBusyResponseArray?.FreeBusyResponse
-          ?? [];
-        const responses = Array.isArray(freeBusyArray)
-          ? freeBusyArray
-          : [freeBusyArray];
-
-        const busyPeriods: { start: Date; end: Date }[] = [];
-
-        for (const fbResp of responses) {
-          const fbView = fbResp?.FreeBusyView ?? {};
-          const calEvents = fbView?.CalendarEventArray?.CalendarEvent ?? [];
-          const evList = Array.isArray(calEvents) ? calEvents : [calEvents];
-
-          for (const ev of evList) {
-            const bt = ev.BusyType ?? "";
-            if (bt === "Free" || bt === "NoData") continue;
-            const startStr = ev.StartTime ?? "";
-            const endStr = ev.EndTime ?? "";
-            if (startStr && endStr) {
-              busyPeriods.push({
-                start: new Date(startStr),
-                end: new Date(endStr),
-              });
-            }
-          }
-        }
-
-        const merged = mergeBusyPeriods(busyPeriods);
-        const freeSlots = findFreeSlots(
-          merged,
-          new Date(startDate),
-          ed ? new Date(ed) : new Date(startDate),
-          startHour,
-          endHour,
-          durationMinutes,
-        );
-
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ freeSlots }),
-          }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-
-  server.registerTool(
-    "find_meeting_time",
-    {
-      description: "Find meeting times that work for multiple people",
-      inputSchema: z.object({
-        emails: z.string().describe(
-          "Comma-separated email addresses of attendees",
-        ),
-        startDate: z.string().describe("Start date in YYYY-MM-DD format"),
-        endDate: z.string().optional().describe(
-          "End date in YYYY-MM-DD format (defaults to startDate)",
-        ),
-        durationMinutes: z.number().default(30).describe(
-          "Minimum slot duration in minutes (default 30)",
-        ),
-        startHour: z.number().default(9).describe(
-          "Working day start hour (0-23, default 9)",
-        ),
-        endHour: z.number().default(18).describe(
-          "Working day end hour (0-23, default 18)",
-        ),
-      }),
-    },
-    async (
-      { emails, startDate, endDate, durationMinutes, startHour, endHour },
-    ) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const emailList = emails.split(",").map((e) => e.trim()).filter(
-          Boolean,
-        );
-        const ed = endDate || startDate;
-
-        const data = await client.getUserAvailability(emailList, startDate, ed);
-
-        const body = data?.Envelope?.Body?.GetUserAvailabilityResponse
-          ?? data?.Envelope?.Body ?? {};
-        const freeBusyArray = body?.FreeBusyResponseArray?.FreeBusyResponse
-          ?? [];
-        const responses = Array.isArray(freeBusyArray)
-          ? freeBusyArray
-          : [freeBusyArray];
-
-        const allBusy: { start: Date; end: Date }[] = [];
-        const attendeeInfo: any[] = [];
-
-        for (let i = 0; i < responses.length; i++) {
-          const fbResp = responses[i];
-          const fbView = fbResp?.FreeBusyView ?? {};
-          const email = emailList[i] || `Person ${i + 1}`;
-
-          const mergedFb = fbView.MergedFreeBusy ?? "";
-          if (mergedFb) {
-            const startTime = new Date(`${startDate}T00:00:00`);
-            const busyPeriods = parseFreeBusyString(mergedFb, startTime);
-            const busyCount = busyPeriods.length;
-            const freeCount = mergedFb.split("").filter((c: string) =>
-              c === "0"
-            ).length;
-            attendeeInfo.push({
-              email,
-              busySlots: busyCount,
-              freeSlots: freeCount,
-            });
-            allBusy.push(...busyPeriods);
-          } else {
-            const calEvents = fbView?.CalendarEventArray?.CalendarEvent ?? [];
-            const evList = Array.isArray(calEvents) ? calEvents : [calEvents];
-            attendeeInfo.push({ email, calendarEvents: evList.length });
-            for (const ev of evList) {
-              const startStr = ev.StartTime ?? "";
-              const endStr = ev.EndTime ?? "";
-              if (startStr && endStr) {
-                allBusy.push({
-                  start: new Date(startStr),
-                  end: new Date(endStr),
-                });
-              }
-            }
-          }
-        }
-
-        const merged = mergeBusyPeriods(allBusy);
-        const freeByDate = findFreeSlots(
-          merged,
-          new Date(startDate),
-          new Date(ed),
-          startHour,
-          endHour,
-          durationMinutes,
-        );
-
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({
-              period: { start: startDate, end: ed },
-              attendees: attendeeInfo,
-              freeSlots: freeByDate,
-            }),
-          }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────
-
-function parseFreeBusyString(
-  fbStr: string,
-  startTime: Date,
-  intervalMinutes: number = 30,
-): { start: Date; end: Date }[] {
-  const periods: { start: Date; end: Date }[] = [];
-  const current = new Date(startTime);
-
-  for (const char of fbStr) {
-    const next = new Date(current.getTime() + intervalMinutes * 60000);
-    if (char !== "0") {
-      periods.push({ start: new Date(current), end: next });
-    }
-    current.setTime(next.getTime());
-  }
-
-  return periods;
-}
-
-function mergeBusyPeriods(
-  periods: { start: Date; end: Date }[],
-): { start: Date; end: Date }[] {
-  if (!periods.length) return [];
-
-  const sorted = [...periods].sort((a, b) =>
-    a.start.getTime() - b.start.getTime()
-  );
-  const merged: { start: Date; end: Date }[] = [{ ...sorted[0] }];
-
-  for (let i = 1; i < sorted.length; i++) {
-    const last = merged[merged.length - 1];
-    if (sorted[i].start <= last.end) {
-      last.end = sorted[i].end > last.end ? sorted[i].end : last.end;
-    } else {
-      merged.push({ ...sorted[i] });
-    }
-  }
-
-  return merged;
-}
-
-function findFreeSlots(
-  busyPeriods: { start: Date; end: Date }[],
-  startDate: Date,
-  endDate: Date,
-  startHour: number,
-  endHour: number,
-  durationMinutes: number,
-): Record<string, { start: string; end: string; durationMinutes: number }[]> {
-  const result: Record<
-    string,
-    { start: string; end: string; durationMinutes: number }[]
-  > = {};
-
-  const current = new Date(startDate);
-  current.setDate(current.getDate());
-  current.setHours(0, 0, 0, 0);
-
-  const end = new Date(endDate);
-  end.setDate(end.getDate() + 1);
-  end.setHours(0, 0, 0, 0);
-
-  while (current < end) {
-    if (current.getDay() !== 0 && current.getDay() !== 6) {
-      const dayStart = new Date(current);
-      dayStart.setHours(startHour, 0, 0, 0);
-
-      const dayEnd = new Date(current);
-      dayEnd.setHours(endHour, 0, 0, 0);
-
-      const dayBusy = busyPeriods
-        .filter((p) => p.start < dayEnd && p.end > dayStart)
-        .map((p) => ({
-          start: p.start < dayStart ? dayStart : p.start,
-          end: p.end > dayEnd ? dayEnd : p.end,
-        }));
-
-      const merged = mergeBusyPeriods(dayBusy);
-
-      const slots: { start: string; end: string; durationMinutes: number }[] =
-        [];
-      let cursor = new Date(dayStart);
-
-      for (const bp of merged) {
-        if (cursor < bp.start) {
-          const gap = (bp.start.getTime() - cursor.getTime()) / 60000;
-          if (gap >= durationMinutes) {
-            slots.push({
-              start: formatTime(cursor),
-              end: formatTime(bp.start),
-              durationMinutes: gap,
-            });
-          }
-        }
-        cursor = bp.end > cursor ? bp.end : cursor;
-      }
-
-      if (cursor < dayEnd) {
-        const gap = (dayEnd.getTime() - cursor.getTime()) / 60000;
-        if (gap >= durationMinutes) {
-          slots.push({
-            start: formatTime(cursor),
-            end: formatTime(dayEnd),
-            durationMinutes: gap,
-          });
-        }
-      }
-
-      if (slots.length) {
-        result[current.toISOString().slice(0, 10)] = slots;
-      }
-    }
-
-    current.setDate(current.getDate() + 1);
-  }
-
-  return result;
-}
-
-function formatTime(d: Date): string {
-  return d.toTimeString().slice(0, 5);
-}

tools/calendar.ts

@@ -1,187 +0,0 @@
-import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import fs from "node:fs";
-import path from "node:path";
-import { z } from "zod/v4";
-import { EwsClient, loadConfig } from "../ews_client.ts";
-
-export function registerCalendarTools(server: McpServer): void {
-  server.registerTool(
-    "get_calendar_events",
-    {
-      description: "Get calendar events within a date range",
-      inputSchema: z.object({
-        startDate: z.string().describe("Start date in YYYY-MM-DD format"),
-        endDate: z.string().describe("End date in YYYY-MM-DD format"),
-        includeBody: z.boolean().default(false).describe(
-          "If True, fetch full event details (organizer, attendees, body) via GetItem",
-        ),
-      }),
-    },
-    async ({ startDate, endDate, includeBody }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const folderId = await client.getFolderId("calendar");
-        const items = await client.findCalendarItems(
-          folderId,
-          `${startDate}T00:00:00`,
-          `${endDate}T23:59:59`,
-        );
-
-        const events = [];
-        for (const item of items) {
-          const event: any = {
-            subject: item.Subject ?? "(No subject)",
-            start: item.Start ?? "",
-            end: item.End ?? "",
-            location: item.Location ?? item.EnhancedLocation?.DisplayName ?? "",
-            isAllDay: item.IsAllDayEvent === "true"
-              || item.IsAllDayEvent === true,
-            isCancelled: item.IsCancelled === "true"
-              || item.IsCancelled === true,
-            isMeeting: true,
-            isRecurring: item.IsRecurring === "true"
-              || item.IsRecurring === true,
-            organizer: "",
-            organizerEmail: "",
-            myResponse: item.MyResponseType ?? "",
-            itemId: item.ItemId?.["@_Id"] ?? "",
-            body: "",
-            requiredAttendees: [],
-            optionalAttendees: [],
-          };
-
-          if (includeBody && event.itemId) {
-            const details = client.extractEmailDetails(item);
-            event.body = details.body;
-            event.requiredAttendees = details.requiredAttendees ?? [];
-            event.optionalAttendees = details.optionalAttendees ?? [];
-            event.organizer = details.fromName;
-            event.organizerEmail = details.from;
-            event.location = details.location || event.location;
-          }
-
-          events.push(event);
-        }
-
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ events, count: events.length }),
-          }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-
-  server.registerTool(
-    "download_event_attachments",
-    {
-      description:
-        "Download all file attachments from a calendar event to disk",
-      inputSchema: z.object({
-        itemId: z.string().describe(
-          "The Exchange ItemId of the calendar event",
-        ),
-        targetFolder: z.string().default("/tmp/attachments").describe(
-          "Local directory to save files (default /tmp/attachments)",
-        ),
-      }),
-    },
-    async ({ itemId, targetFolder }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const item = await client.getItem(itemId);
-        const email = client.extractEmailDetails(item);
-        const attachments = email.attachments ?? [];
-
-        const fileAttachments = attachments.filter(
-          (a: any) => a.attachmentId && !a.isInline,
-        );
-
-        if (!fileAttachments.length) {
-          return {
-            content: [{
-              type: "text" as const,
-              text: JSON.stringify({
-                success: true,
-                downloaded: [],
-                count: 0,
-                message: "No downloadable file attachments.",
-              }),
-            }],
-          };
-        }
-
-        fs.mkdirSync(targetFolder, { recursive: true });
-
-        const downloaded = [];
-        const errors = [];
-        const usedNames = new Set<string>();
-
-        for (const att of fileAttachments) {
-          try {
-            const result = await client.getAttachment(att.attachmentId);
-            let filename = path.basename(result.name);
-            if (!filename) filename = att.name || "attachment";
-
-            const baseName = filename;
-            const dotIdx = baseName.lastIndexOf(".");
-            const namePart = dotIdx > 0 ? baseName.slice(0, dotIdx) : baseName;
-            const extPart = dotIdx > 0 ? baseName.slice(dotIdx) : "";
-
-            let counter = 1;
-            let finalName = filename;
-            while (usedNames.has(finalName.toLowerCase())) {
-              finalName = extPart
-                ? `${namePart}_${counter}${extPart}`
-                : `${namePart}_${counter}`;
-              counter++;
-            }
-            usedNames.add(finalName.toLowerCase());
-
-            const filepath = path.join(targetFolder, finalName);
-            fs.writeFileSync(filepath, result.content);
-
-            downloaded.push({
-              name: finalName,
-              path: filepath,
-              size: result.content.length,
-              contentType: result.contentType,
-            });
-          } catch (e: any) {
-            errors.push({
-              name: att.name || "unknown",
-              error: e.message ?? String(e),
-            });
-          }
-        }
-
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({
-              success: errors.length === 0,
-              downloaded,
-              count: downloaded.length,
-              ...(errors.length ? { errors } : {}),
-            }),
-          }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-}

tools/email.ts

@@ -1,6 +1,4 @@
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import fs from "node:fs";
-import path from "node:path";
 import { z } from "zod/v4";
 import { EwsClient, loadConfig } from "../ews_client.ts";
 
@@ -32,92 +30,27 @@ export function registerEmailTools(server: McpServer): void {
         idsOnly: z.boolean().default(false).describe(
           "If True, return only item IDs and dates (max limit 500)",
         ),
-        query: z.string().optional().describe(
-          "Optional text to search for within the folder",
-        ),
-        queryScope: z.enum(["all", "subject", "body", "from"]).default("all")
-          .describe("Where to search (only used when query is set)"),
       }),
     },
-    async (
+    async ({ folder, limit, offset, includeBody, unreadOnly, idsOnly }) => {
-      {
-        folder,
-        limit,
-        offset,
-        includeBody,
-        unreadOnly,
-        idsOnly,
-        query,
-        queryScope,
-      },
-    ) => {
       try {
         const client = getClient();
         const maxLimit = idsOnly ? 500 : 50;
         if (limit > maxLimit) limit = maxLimit;
-        offset = Math.max(0, offset);
 
         const folderId = await client.getFolderId(folder);
         const baseShape = idsOnly ? "IdOnly" : "AllProperties";
 
-        if (query && !query.trim()) query = undefined;
+        let restriction = "";
-
-        const restrictions: string[] = [];
-
         if (unreadOnly) {
-          restrictions.push(`\
+          restriction = `\
+      <m:Restriction>
         <t:IsEqualTo>
           <t:FieldURI FieldURI="message:IsRead"/>
           <t:FieldURIOrConstant>
             <t:Constant Value="false"/>
           </t:FieldURIOrConstant>
-        </t:IsEqualTo>`);
+        </t:IsEqualTo>
-        }
-
-        if (query) {
-          function containsExpression(fieldUri: string, value: string): string {
-            return `\
-        <t:Contains ContainmentMode="Substring" ContainmentComparison="IgnoreCase">
-          <t:FieldURI FieldURI="${fieldUri}"/>
-          <t:Constant Value="${
-              value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(
-                />/g,
-                "&gt;",
-              ).replace(/"/g, "&quot;")
-            }"/>
-        </t:Contains>`;
-          }
-
-          const fieldUriMap: Record<string, string> = {
-            subject: "item:Subject",
-            body: "item:Body",
-            from: "message:From",
-          };
-
-          if (queryScope === "all") {
-            restrictions.push(`\
-        <t:Or>
-          ${containsExpression("item:Subject", query)}
-          ${containsExpression("item:Body", query)}
-        </t:Or>`);
-          } else {
-            const fieldUri = fieldUriMap[queryScope];
-            restrictions.push(containsExpression(fieldUri, query));
-          }
-        }
-
-        let restriction = "";
-        if (restrictions.length === 1) {
-          restriction = `\
-      <m:Restriction>
-        ${restrictions[0]}
-      </m:Restriction>`;
-        } else if (restrictions.length > 1) {
-          restriction = `\
-      <m:Restriction>
-        <t:And>
-          ${restrictions.join("\n")}
-        </t:And>
       </m:Restriction>`;
         }
 
@@ -205,150 +138,143 @@ export function registerEmailTools(server: McpServer): void {
   );
 
   server.registerTool(
-    "mark_email_read",
+    "search_emails",
     {
-      description: "Mark one or more emails as read or unread",
+      description: "Search emails by text across one or all folders",
       inputSchema: z.object({
-        itemIds: z.array(z.string()).describe(
+        query: z.string().describe("The text to search for"),
-          "List of Exchange ItemIds to update",
+        folderId: z.string().optional().describe(
+          "Optional folder ID to limit the search. When omitted, searches all mail folders",
         ),
-        isRead: z.boolean().default(true).describe(
+        maxResults: z.number().default(20).describe(
-          "True to mark as read, False to mark as unread",
+          "Maximum number of results (default 20, max 100)",
         ),
+        searchScope: z.enum(["all", "subject", "body", "from"]).default("all")
+          .describe("Where to search"),
       }),
     },
-    async ({ itemIds, isRead }) => {
+    async ({ query, folderId, maxResults, searchScope }) => {
       try {
-        const client = new EwsClient(loadConfig());
+        const client = getClient();
-        const responses = await client.updateItems(itemIds, [
-          { fieldUri: "message:IsRead", value: isRead },
-        ]);
 
-        const errors = responses
+        if (!query.trim()) {
-          .filter((r: any) => r.ResponseClass === "Error")
-          .map((r: any) => r.MessageText ?? "Unknown error");
-
-        if (errors.length) {
-          return {
-            content: [{
-              type: "text" as const,
-              text: JSON.stringify({ error: errors.join("; ") }),
-            }],
-          };
-        }
-
-        const status = isRead ? "read" : "unread";
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({
-              success: true,
-              message: `Marked ${itemIds.length} email(s) as ${status}.`,
-            }),
-          }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-
-  server.registerTool(
-    "download_attachments",
-    {
-      description: "Download all file attachments from an email to disk",
-      inputSchema: z.object({
-        itemId: z.string().describe("The Exchange ItemId of the email"),
-        targetFolder: z.string().default("/tmp/attachments").describe(
-          "Local directory to save files (default /tmp/attachments)",
-        ),
-      }),
-    },
-    async ({ itemId, targetFolder }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const item = await client.getItem(itemId);
-        const email = client.extractEmailDetails(item);
-        const attachments = email.attachments ?? [];
-
-        const fileAttachments = attachments.filter(
-          (a: any) => a.attachmentId && !a.isInline,
-        );
-
-        if (!fileAttachments.length) {
           return {
             content: [{
               type: "text" as const,
               text: JSON.stringify({
-                success: true,
+                error: "query must not be empty",
-                downloaded: [],
+                results: [],
-                count: 0,
-                message: "No downloadable file attachments.",
               }),
             }],
           };
         }
 
-        fs.mkdirSync(targetFolder, { recursive: true });
+        maxResults = Math.max(1, Math.min(maxResults, 100));
 
-        const downloaded = [];
+        const fieldUriMap: Record<string, string> = {
-        const errors = [];
+          subject: "item:Subject",
-        const usedNames = new Set<string>();
+          body: "item:Body",
+          from: "message:From",
+        };
 
-        for (const att of fileAttachments) {
+        function containsExpression(fieldUri: string, value: string): string {
-          try {
+          return `\
-            const result = await client.getAttachment(att.attachmentId);
+        <t:Contains ContainmentMode="Substring" ContainmentComparison="IgnoreCase">
-            let filename = path.basename(result.name);
+          <t:FieldURI FieldURI="${fieldUri}"/>
-            if (!filename) filename = att.name || "attachment";
+          <t:Constant Value="${
-
+            value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(
-            const baseName = filename;
+              />/g,
-            const dotIdx = baseName.lastIndexOf(".");
+              "&gt;",
-            const namePart = dotIdx > 0 ? baseName.slice(0, dotIdx) : baseName;
+            ).replace(/"/g, "&quot;")
-            const extPart = dotIdx > 0 ? baseName.slice(dotIdx) : "";
+          }"/>
-
+        </t:Contains>`;
-            let counter = 1;
-            let finalName = filename;
-            while (usedNames.has(finalName.toLowerCase())) {
-              finalName = extPart
-                ? `${namePart}_${counter}${extPart}`
-                : `${namePart}_${counter}`;
-              counter++;
-            }
-            usedNames.add(finalName.toLowerCase());
-
-            const filepath = path.join(targetFolder, finalName);
-            fs.writeFileSync(filepath, result.content);
-
-            downloaded.push({
-              name: finalName,
-              path: filepath,
-              size: result.content.length,
-              contentType: result.contentType,
-            });
-          } catch (e: any) {
-            errors.push({
-              name: att.name || "unknown",
-              error: e.message ?? String(e),
-            });
-          }
         }
 
-        return {
+        let restriction: string;
-          content: [{
+        if (searchScope === "all") {
-            type: "text" as const,
+          restriction = `\
-            text: JSON.stringify({
+      <m:Restriction>
-              success: errors.length === 0,
+        <t:Or>
-              downloaded,
+          ${containsExpression("item:Subject", query)}
-              count: downloaded.length,
+          ${containsExpression("item:Body", query)}
-              ...(errors.length ? { errors } : {}),
+        </t:Or>
-            }),
+      </m:Restriction>`;
-          }],
+        } else {
-        };
+          const fieldUri = fieldUriMap[searchScope];
+          if (!fieldUri) {
+            return {
+              content: [{
+                type: "text" as const,
+                text: JSON.stringify({
+                  error: `unsupported search_scope: ${searchScope}`,
+                  results: [],
+                }),
+              }],
+            };
+          }
+          restriction = `\
+      <m:Restriction>
+        ${containsExpression(fieldUri, query)}
+      </m:Restriction>`;
+        }
+
+        const traversal = folderId ? "Shallow" : "Deep";
+
+        if (folderId) {
+          const items = await client.findItems(folderId, {
+            limit: maxResults,
+            restriction,
+            traversal,
+          });
+          const results = formatSearchResults(items, client, maxResults);
+
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                query,
+                searchScope,
+                folderId,
+                totalResults: results.length,
+                results,
+              }),
+            }],
+          };
+        } else {
+          const folders = await client.findFolders("msgfolderroot", true);
+          const allResults = [];
+
+          for (const f of folders) {
+            if (allResults.length >= maxResults) break;
+            const remaining = maxResults - allResults.length;
+            const items = await client.findItems(f.id, {
+              limit: remaining,
+              restriction,
+              traversal: "Shallow",
+            });
+            const formatted = formatSearchResults(items, client, remaining);
+
+            for (const r of formatted) {
+              r.folderId = f.id;
+              r.folderName = f.name;
+              allResults.push(r);
+              if (allResults.length >= maxResults) break;
+            }
+          }
+
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                query,
+                searchScope,
+                folderId: "all",
+                totalResults: allResults.length,
+                results: allResults,
+              }),
+            }],
+          };
+        }
       } catch (error: any) {
         return {
           content: [{
@@ -360,3 +286,30 @@ export function registerEmailTools(server: McpServer): void {
     },
   );
 }
+
+function formatSearchResults(
+  items: any[],
+  client: EwsClient,
+  maxResults: number,
+): any[] {
+  const results: any[] = [];
+  for (const item of items) {
+    if (results.length >= maxResults) break;
+    const summary = client.extractEmailSummary(item);
+
+    const bodyHtml = item.Body?.Value ?? item.Body?.["#text"] ?? "";
+    const bodyType = item.Body?.["@_BodyType"] ?? "HTML";
+    let bodyPreview = "";
+    if (bodyType === "HTML" && bodyHtml) {
+      bodyPreview = bodyHtml.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ")
+        .trim().slice(0, 200);
+    } else {
+      bodyPreview = bodyHtml.slice(0, 200);
+    }
+
+    summary.preview = bodyPreview;
+
+    results.push(summary);
+  }
+  return results;
+}

tools/people.ts

@@ -1,98 +0,0 @@
-import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod/v4";
-import { EwsClient, loadConfig } from "../ews_client.ts";
-
-export function registerPeopleTools(server: McpServer): void {
-  server.registerTool(
-    "find_person",
-    {
-      description: "Search for people in the corporate directory",
-      inputSchema: z.object({
-        query: z.string().describe(
-          "Name, email address, or keyword to search for",
-        ),
-      }),
-    },
-    async ({ query }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const resolutions = await client.resolveNames(query, true);
-
-        const people = resolutions.map((r: any) => {
-          const mailbox = r.Mailbox ?? {};
-          const contact = r.Contact ?? {};
-
-          const person: any = {
-            name: mailbox.Name ?? contact.DisplayName ?? "",
-            email: mailbox.EmailAddress ?? "",
-            mailboxType: mailbox.MailboxType ?? "",
-            firstName: contact.GivenName ?? "",
-            lastName: contact.Surname ?? "",
-            jobTitle: contact.JobTitle ?? "",
-            department: contact.Department ?? "",
-            company: contact.CompanyName ?? "",
-            office: contact.OfficeLocation ?? "",
-            alias: contact.Alias ?? "",
-            manager: "",
-            managerEmail: "",
-            phones: {},
-            address: "",
-            directReports: [],
-          };
-
-          const phones = contact.PhoneNumbers?.PhoneNumber ?? [];
-          const phoneList = Array.isArray(phones) ? phones : [phones];
-          for (const p of phoneList) {
-            if (p?.Key && p?.PhoneNumber) {
-              person.phones[p.Key] = p.PhoneNumber;
-            }
-          }
-
-          const addrs = contact.PhysicalAddresses?.PhysicalAddress ?? [];
-          const addrList = Array.isArray(addrs) ? addrs : [addrs];
-          for (const a of addrList) {
-            if (a?.Key === "Business") {
-              const parts = [a.Street, a.City, a.PostalCode, a.CountryOrRegion]
-                .filter(Boolean);
-              if (parts.length) {
-                person.address = parts.join(", ");
-              }
-            }
-          }
-
-          const managerData = contact.ManagerMailbox?.Mailbox ?? {};
-          if (managerData.Name || managerData.EmailAddress) {
-            person.manager = managerData.Name ?? "";
-            person.managerEmail = managerData.EmailAddress ?? "";
-          } else if (contact.Manager) {
-            person.manager = contact.Manager;
-          }
-
-          const reports = contact.DirectReports?.DirectReport ?? [];
-          const reportList = Array.isArray(reports) ? reports : [reports];
-          for (const rp of reportList) {
-            if (rp?.Name || rp?.EmailAddress) {
-              person.directReports.push({
-                name: rp.Name ?? "",
-                email: rp.EmailAddress ?? "",
-              });
-            }
-          }
-
-          return person;
-        });
-
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify(people) }],
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-}

types/calendar_event.ts

@@ -1,17 +0,0 @@
-export interface CalendarEvent {
-  subject: string;
-  start: string;
-  end: string;
-  location: string;
-  isAllDay: boolean;
-  isCancelled: boolean;
-  isMeeting: boolean;
-  isRecurring: boolean;
-  organizer: string;
-  organizerEmail: string;
-  myResponse: string;
-  itemId: string;
-  body: string;
-  requiredAttendees: string[];
-  optionalAttendees: string[];
-}

types/email.ts

@@ -1,32 +0,0 @@
-export interface Email {
-  subject: string;
-  from: string;
-  fromName: string;
-  date: string;
-  isRead: boolean;
-  hasAttachments: boolean;
-  hasLinks: boolean;
-  itemId: string;
-  size: number;
-  isMeeting: boolean;
-  itemType: string;
-  to: string[];
-  cc: string[];
-  body: string;
-  bodyType: string;
-  attachments: Attachment[];
-  preview: string;
-  location?: string;
-  start?: string;
-  end?: string;
-  requiredAttendees?: string[];
-  optionalAttendees?: string[];
-}
-
-export interface Attachment {
-  name: string;
-  size: number;
-  contentType: string;
-  attachmentId: string;
-  isInline: boolean;
-}

types/folder.ts

@@ -1,7 +0,0 @@
-export interface Folder {
-  name: string;
-  id: string;
-  totalCount: number;
-  unreadCount: number;
-  childFolderCount: number;
-}

types/free_slot.ts

@@ -1,6 +0,0 @@
-export interface FreeSlot {
-  date: string;
-  start: string;
-  end: string;
-  durationMinutes: number;
-}

types/login_config.ts

@@ -1,6 +0,0 @@
-export interface LoginConfig {
-  serverUrl: string;
-  email: string;
-  username: string;
-  domain?: string;
-}

types/meeting_result.ts

@@ -1,11 +0,0 @@
-export interface MeetingResult {
-  success: boolean;
-  subject: string;
-  date: string;
-  startTime: string;
-  endTime: string;
-  location: string;
-  requiredAttendees: string[];
-  optionalAttendees: string[];
-  error: string;
-}

types/person.ts

@@ -1,17 +0,0 @@
-export interface Person {
-  name: string;
-  email: string;
-  mailboxType: string;
-  firstName: string;
-  lastName: string;
-  jobTitle: string;
-  department: string;
-  company: string;
-  office: string;
-  alias: string;
-  manager: string;
-  managerEmail: string;
-  phones: Record<string, string>;
-  address: string;
-  directReports: Array<{ name: string; email: string }>;
-}