w

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true

.gitattributes

@@ -0,0 +1 @@
+/.pnp.*  binary linguist-generated

.gitignore

@@ -0,0 +1,14 @@
+.cache
+.data
+.DS_Store
+.env
+.git
+.idea
+.pnp.*
+.target
+.tmp
+.vscode
+.yarn
+node_modules
+config.json
+data/

dockerfile

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

dprint.json

@@ -0,0 +1,22 @@
+{
+  "lineWidth": 80,
+  "indentWidth": 2,
+  "typescript": {
+    "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/json-0.23.0.wasm",
+    "https://plugins.dprint.dev/markdown-0.22.1.wasm",
+    "https://plugins.dprint.dev/dockerfile-0.4.1.wasm"
+  ]
+}

ews_client.ts

@@ -0,0 +1,729 @@
+import { XMLParser } from "fast-xml-parser";
+import fs from "node:fs";
+import https from "node:https";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { promisify } from "node:util";
+import type { Email } from "./types/email.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));
+
+const SSL_OP_LEGACY_SERVER_CONNECT = 0x00000004;
+
+const AGENT = new https.Agent({
+  keepAlive: true,
+  rejectUnauthorized: false,
+  secureOptions: SSL_OP_LEGACY_SERVER_CONNECT,
+});
+
+const PARSER = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  removeNSPrefix: true,
+  textNodeName: "#text",
+});
+
+const DISTINGUISHED_FOLDERS: Record<string, string> = {
+  inbox: "inbox",
+  "входящие": "inbox",
+  sent: "sentitems",
+  "отправленные": "sentitems",
+  drafts: "drafts",
+  "черновики": "drafts",
+  deleted: "deleteditems",
+  "удаленные": "deleteditems",
+  junk: "junkemail",
+  "нежелательная почта": "junkemail",
+  outbox: "outbox",
+  "исходящие": "outbox",
+  calendar: "calendar",
+  "календарь": "calendar",
+};
+
+function buildSoapEnvelope(body: string): string {
+  return `<?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>
+${body}
+  </s:Body>
+</s:Envelope>`;
+}
+
+function configFilePath(): string {
+  return path.join(dataDir, "config.json");
+}
+
+export function loadConfig(): LoginConfig {
+  const filePath = configFilePath();
+  if (!fs.existsSync(filePath)) {
+    throw new Error("Not logged in. Use the login tool first.");
+  }
+  return JSON.parse(fs.readFileSync(filePath, "utf-8")) as LoginConfig;
+}
+
+export function saveConfig(config: LoginConfig): void {
+  const filePath = configFilePath();
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+export function clearConfig(): void {
+  const filePath = configFilePath();
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+  clearPassword();
+}
+
+export class EwsClient {
+  private config: LoginConfig;
+  private ewsUrl: string;
+
+  constructor(config: LoginConfig, password?: string) {
+    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,
+      agent: AGENT,
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        SOAPAction: soapAction,
+      },
+      body,
+    });
+
+    if (typeof res.body !== "string") {
+      throw new Error(`NTLM request failed, status=${res.statusCode}`);
+    }
+
+    const parsed = PARSER.parse(res.body);
+    return parsed;
+  }
+
+  private extractResponseMessages(data: any): any[] {
+    const body = data?.Envelope?.Body;
+    if (!body) return [];
+
+    const firstKey = Object.keys(body).find((k) => k.endsWith("Response"));
+    if (!firstKey) return [];
+
+    const rm = body[firstKey]?.ResponseMessages;
+    if (!rm) return [];
+
+    const msgKey = Object.keys(rm).find((k) => k.endsWith("ResponseMessage"));
+    if (!msgKey) return [];
+
+    const msgs = rm[msgKey];
+    return Array.isArray(msgs) ? msgs : [msgs];
+  }
+
+  async verifyConnection(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      await this.getFolderId("inbox");
+      return { ok: true };
+    } catch (error: any) {
+      return { ok: false, error: error.message ?? String(error) };
+    }
+  }
+
+  async getFolderId(folderName: string): Promise<string> {
+    const lower = folderName.toLowerCase();
+    const distinguished = DISTINGUISHED_FOLDERS[lower];
+
+    if (distinguished) {
+      const soap = buildSoapEnvelope(`\
+    <m:GetFolder>
+      <m:FolderShape>
+        <t:BaseShape>IdOnly</t:BaseShape>
+      </m:FolderShape>
+      <m:FolderIds>
+        <t:DistinguishedFolderId Id="${distinguished}"/>
+      </m:FolderIds>
+    </m:GetFolder>`);
+
+      const data = await this.soapRequest(
+        soap,
+        "http://schemas.microsoft.com/exchange/services/2006/messages/GetFolder",
+      );
+
+      for (const msg of this.extractResponseMessages(data)) {
+        const folder = msg?.Folders?.Folder;
+        if (folder?.FolderId?.["@_Id"]) {
+          return folder.FolderId["@_Id"];
+        }
+      }
+    }
+
+    const soap = buildSoapEnvelope(`\
+    <m:FindFolder Traversal="Shallow">
+      <m:FolderShape>
+        <t:BaseShape>Default</t:BaseShape>
+      </m:FolderShape>
+      <m:ParentFolderIds>
+        <t:DistinguishedFolderId Id="msgfolderroot"/>
+      </m:ParentFolderIds>
+      <m:IndexedPageFolderView MaxEntriesReturned="200" Offset="0" BasePoint="Beginning"/>
+    </m:FindFolder>`);
+
+    const data = await this.soapRequest(
+      soap,
+      "http://schemas.microsoft.com/exchange/services/2006/messages/FindFolder",
+    );
+
+    for (const msg of this.extractResponseMessages(data)) {
+      const folders = msg?.RootFolder?.Folders?.Folder;
+      if (!folders) continue;
+      const list = Array.isArray(folders) ? folders : [folders];
+      for (const f of list) {
+        if (f.DisplayName?.toLowerCase() === lower) {
+          return f.FolderId?.["@_Id"] ?? "";
+        }
+      }
+    }
+
+    throw new Error(`Folder '${folderName}' not found`);
+  }
+
+  async findItems(
+    folderId: string,
+    options: {
+      limit?: number;
+      offset?: number;
+      baseShape?: string;
+      restriction?: string;
+      traversal?: string;
+    } = {},
+  ): Promise<any[]> {
+    const {
+      limit = 10,
+      offset = 0,
+      baseShape = "AllProperties",
+      restriction = "",
+      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>
+        <t:BaseShape>${baseShape}</t:BaseShape>
+      </m:ItemShape>
+      <m:IndexedPageItemView MaxEntriesReturned="${limit}" Offset="${offset}" BasePoint="Beginning"/>
+      <m:ParentFolderIds>
+        ${folderIdXml}
+      </m:ParentFolderIds>
+      <m:SortOrder>
+        <t:FieldOrder Order="Descending">
+          <t:FieldURI FieldURI="item:DateTimeReceived"/>
+        </t:FieldOrder>
+      </m:SortOrder>
+${restriction}
+    </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?.Message
+        ?? msg?.RootFolder?.Items?.CalendarItem;
+      if (!items) continue;
+      return Array.isArray(items) ? items : [items];
+    }
+
+    return [];
+  }
+
+  async getItem(itemId: string): Promise<any> {
+    const soap = buildSoapEnvelope(`\
+    <m:GetItem>
+      <m:ItemShape>
+        <t:BaseShape>AllProperties</t:BaseShape>
+        <t:BodyType>HTML</t:BodyType>
+      </m:ItemShape>
+      <m:ItemIds>
+        <t:ItemId Id="${itemId}"/>
+      </m:ItemIds>
+    </m:GetItem>`);
+
+    const data = await this.soapRequest(
+      soap,
+      "http://schemas.microsoft.com/exchange/services/2006/messages/GetItem",
+    );
+
+    for (const msg of this.extractResponseMessages(data)) {
+      const items = msg?.Items;
+      if (!items) continue;
+
+      const itemKey = Object.keys(items).find((k) =>
+        [
+          "Message",
+          "CalendarItem",
+          "MeetingRequest",
+          "MeetingResponse",
+          "MeetingCancellation",
+        ].includes(k)
+      );
+      if (itemKey) {
+        return items[itemKey];
+      }
+    }
+
+    throw new Error(`Item '${itemId}' not found`);
+  }
+
+  async findFolders(
+    parentFolderId: string,
+    recursive: boolean = false,
+  ): Promise<Folder[]> {
+    const traversal = recursive ? "Deep" : "Shallow";
+    const isDistinguished =
+      DISTINGUISHED_FOLDERS[parentFolderId.toLowerCase()] !== undefined
+      || ["msgfolderroot"].includes(parentFolderId.toLowerCase());
+
+    const folderIdXml = isDistinguished
+      ? `<t:DistinguishedFolderId Id="${parentFolderId}"/>`
+      : `<t:FolderId Id="${parentFolderId}"/>`;
+
+    const soap = buildSoapEnvelope(`\
+    <m:FindFolder Traversal="${traversal}">
+      <m:FolderShape>
+        <t:BaseShape>Default</t:BaseShape>
+      </m:FolderShape>
+      <m:ParentFolderIds>
+        ${folderIdXml}
+      </m:ParentFolderIds>
+      <m:IndexedPageFolderView MaxEntriesReturned="200" Offset="0" BasePoint="Beginning"/>
+    </m:FindFolder>`);
+
+    const data = await this.soapRequest(
+      soap,
+      "http://schemas.microsoft.com/exchange/services/2006/messages/FindFolder",
+    );
+
+    const folders: Folder[] = [];
+
+    for (const msg of this.extractResponseMessages(data)) {
+      const folderList = msg?.RootFolder?.Folders?.Folder;
+      if (!folderList) continue;
+      const list = Array.isArray(folderList) ? folderList : [folderList];
+
+      for (const f of list) {
+        folders.push({
+          name: f.DisplayName ?? "Unknown",
+          id: f.FolderId?.["@_Id"] ?? "",
+          totalCount: f.TotalCount ?? 0,
+          unreadCount: f.UnreadCount ?? 0,
+          childFolderCount: f.ChildFolderCount ?? 0,
+        });
+      }
+    }
+
+    return folders;
+  }
+
+  extractEmailSummary(item: any): Email {
+    const itemType = item["@_xsi_type"] ?? item.__type ?? "";
+    const isMeeting =
+      /MeetingRequest|MeetingResponse|MeetingCancellation|CalendarItem/i.test(
+        itemType,
+      );
+
+    const fromMailbox = item.From?.Mailbox
+      ?? item.Organizer?.Mailbox
+      ?? item.Sender?.Mailbox
+      ?? {};
+
+    const email: Email = {
+      subject: item.Subject ?? "(No subject)",
+      from: fromMailbox.EmailAddress ?? "",
+      fromName: fromMailbox.Name ?? "",
+      date: item.DateTimeSent ?? item.DateTimeReceived ?? item.DateTimeCreated
+        ?? "",
+      isRead: item.IsRead === "true" || item.IsRead === true,
+      hasAttachments: item.HasAttachments === "true"
+        || item.HasAttachments === true,
+      hasLinks: false,
+      itemId: item.ItemId?.["@_Id"] ?? "",
+      size: item.Size ? Number(item.Size) : 0,
+      isMeeting,
+      itemType: itemType || "Message",
+      to: [],
+      cc: [],
+      body: "",
+      bodyType: "Text",
+      attachments: [],
+      preview: item.Preview ?? "",
+    };
+
+    if (item.DisplayTo) {
+      email.to = item.DisplayTo.split(";").map((t: string) => t.trim()).filter(
+        Boolean,
+      );
+    }
+    if (item.DisplayCc) {
+      email.cc = item.DisplayCc.split(";").map((c: string) => c.trim()).filter(
+        Boolean,
+      );
+    }
+
+    if (isMeeting) {
+      email.location = item.Location ?? "";
+      email.start = item.Start ?? item.StartWallClock ?? item.ReminderDueBy
+        ?? "";
+      email.end = item.End ?? item.EndWallClock ?? "";
+    }
+
+    return email;
+  }
+
+  extractEmailDetails(item: any): Email {
+    const email = this.extractEmailSummary(item);
+
+    const bodyVal = item.Body?.Value ?? item.Body?.["#text"] ?? "";
+    const bodyType = item.Body?.["@_BodyType"] ?? item.Body?.BodyType ?? "Text";
+
+    if (bodyType === "HTML") {
+      email.hasLinks = /<a\s/i.test(bodyVal);
+      email.body = this.htmlToText(bodyVal);
+    } else {
+      email.body = bodyVal;
+    }
+    email.bodyType = bodyType;
+
+    const toRecipients = item.ToRecipients?.Mailbox ?? [];
+    email.to = (Array.isArray(toRecipients) ? toRecipients : [toRecipients])
+      .map((r: any) => {
+        const name = r.Name ?? "";
+        const addr = r.EmailAddress ?? "";
+        return name && addr ? `${name} <${addr}>` : addr;
+      })
+      .filter(Boolean);
+
+    const ccRecipients = item.CcRecipients?.Mailbox ?? [];
+    email.cc = (Array.isArray(ccRecipients) ? ccRecipients : [ccRecipients])
+      .map((r: any) => {
+        const name = r.Name ?? "";
+        const addr = r.EmailAddress ?? "";
+        return name && addr ? `${name} <${addr}>` : addr;
+      })
+      .filter(Boolean);
+
+    const attachments = item.Attachments?.FileAttachment ?? [];
+    const attList = Array.isArray(attachments) ? attachments : [attachments];
+    email.attachments = attList
+      .filter((a: any) => a)
+      .map((a: any) => ({
+        name: a.Name ?? "",
+        size: a.Size ? Number(a.Size) : 0,
+        contentType: a.ContentType ?? "",
+        attachmentId: a.AttachmentId?.["@_Id"] ?? "",
+        isInline: a.IsInline === "true" || a.IsInline === true,
+      }));
+
+    const isMeeting =
+      /MeetingRequest|MeetingResponse|MeetingCancellation|CalendarItem/i.test(
+        item["@_xsi_type"] ?? "",
+      );
+    if (isMeeting) {
+      email.location = item.Location ?? item.EnhancedLocation?.DisplayName
+        ?? "";
+      email.start = item.Start ?? "";
+      email.end = item.End ?? "";
+
+      const reqAtt = item.RequiredAttendees?.Attendee ?? [];
+      email.requiredAttendees = (Array.isArray(reqAtt) ? reqAtt : [reqAtt])
+        .map((a: any) => {
+          const mb = a.Mailbox ?? {};
+          const name = mb.Name ?? "";
+          const addr = mb.EmailAddress ?? "";
+          return name && addr ? `${name} <${addr}>` : addr;
+        })
+        .filter(Boolean);
+
+      const optAtt = item.OptionalAttendees?.Attendee ?? [];
+      email.optionalAttendees = (Array.isArray(optAtt) ? optAtt : [optAtt])
+        .map((a: any) => {
+          const mb = a.Mailbox ?? {};
+          const name = mb.Name ?? "";
+          const addr = mb.EmailAddress ?? "";
+          return name && addr ? `${name} <${addr}>` : addr;
+        })
+        .filter(Boolean);
+    }
+
+    return email;
+  }
+
+  private htmlToText(html: string): string {
+    if (!html) return "";
+    let text = html.replace(/<script[^>]*>.*?<\/script>/gis, "");
+    text = text.replace(/<style[^>]*>.*?<\/style>/gis, "");
+    text = text.replace(/<br\s*\/?>/gi, "\n");
+    text = text.replace(/<p[^>]*>/gi, "\n");
+    text = text.replace(/<\/p>/gi, "");
+    text = text.replace(/<div[^>]*>/gi, "\n");
+    text = text.replace(/<\/div>/gi, "");
+    text = text.replace(/<[^>]+>/g, "");
+    text = text.replace(/&nbsp;/g, " ");
+    text = text.replace(/&amp;/g, "&");
+    text = text.replace(/&lt;/g, "<");
+    text = text.replace(/&gt;/g, ">");
+    text = text.replace(/&quot;/g, "\"");
+    text = text.replace(/&#39;/g, "'");
+    text = text.replace(/\n\s*\n/g, "\n\n");
+    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

@@ -0,0 +1,142 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+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")
+  .description("Exchange MCP Server — EWS integration via MCP")
+  .option("--transport <type>", "Transport: stdio or sse", "stdio")
+  .option(
+    "--token-hash <hash>",
+    "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("--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",
+    version: "1.0.0",
+  });
+
+  registerAuthTools(server);
+  registerEmailTools(server);
+  registerFolderTools(server);
+  registerCalendarTools(server);
+  registerAvailabilityTools(server);
+  registerPeopleTools(server);
+
+  return server;
+}
+
+async function runStdio() {
+  const server = buildServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+async function runSSE() {
+  const transports = new Map<string, SSEServerTransport>();
+
+  const httpServer = http.createServer(async (req, res) => {
+    if (options.tokenHash) {
+      const auth = req.headers.authorization || "";
+      const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+      const hash = crypto.createHash("sha256").update(token).digest("hex");
+      if (hash !== options.tokenHash) {
+        res.writeHead(401, { "Content-Type": "text/plain" });
+        res.end("Unauthorized");
+        return;
+      }
+    }
+
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      "Content-Type, Authorization",
+    );
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+
+    if (req.method === "GET") {
+      const transport = new SSEServerTransport("/sse", res);
+      const server = buildServer();
+      await server.connect(transport);
+
+      transports.set(transport.sessionId, transport);
+      res.on("close", () => {
+        transports.delete(transport.sessionId);
+      });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/sse") {
+      const sessionId = url.searchParams.get("sessionId") || "";
+      const transport = transports.get(sessionId);
+      if (!transport) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Session not found");
+        return;
+      }
+
+      await transport.handlePostMessage(req, res);
+      return;
+    }
+
+    res.writeHead(404);
+    res.end("Not found");
+  });
+
+  const port = Number(options.port);
+  httpServer.listen(port, options.host);
+
+  console.error(
+    `Exchange MCP Server running via SSE on http://${options.host}:${port}`,
+  );
+}
+
+async function main() {
+  const transportType: string = options.transport;
+
+  switch (transportType) {
+    case "stdio":
+      await runStdio();
+      break;
+    case "sse":
+      await runSSE();
+      break;
+    default:
+      console.error(
+        `Unsupported transport: "${transportType}". Use "stdio" or "sse".`,
+      );
+      process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "exchange-mcp",
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node main.ts",
+    "format": "dprint fmt"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^15.0.0",
+    "fast-xml-parser": "^5.2.0",
+    "httpntlm": "^1.8.13",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.3"
+  }
+}

tools/auth.ts

@@ -0,0 +1,171 @@
+import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod/v4";
+import {
+  clearConfig,
+  EwsClient,
+  hasPassword,
+  loadConfig,
+  saveConfig,
+  setPassword,
+} from "../ews_client.ts";
+import type { LoginConfig } from "../types/login_config.ts";
+
+export function registerAuthTools(server: McpServer): void {
+  server.registerTool(
+    "login",
+    {
+      description: "Authenticate to Exchange EWS using NTLM credentials."
+        + " On first use all fields except domain are required."
+        + " On subsequent logins only password is needed — previously saved"
+        + " serverUrl, email, username, and domain are reused automatically from config."
+        + " Returns {success, message} on success or {success, error} on failure.",
+      inputSchema: z.object({
+        serverUrl: z.string().optional().describe("Server URL"),
+        email: z.string().optional().describe("Email address"),
+        username: z.string().optional().describe("NTLM username"),
+        password: z.string().describe("NTLM password"),
+        domain: z.string().optional().describe("NTLM domain"),
+      }),
+    },
+    async ({ serverUrl, email, username, password, domain }) => {
+      try {
+        let savedConfig: Partial<LoginConfig> = {};
+        try {
+          savedConfig = loadConfig();
+        } catch {
+          // no saved config — all fields must be provided
+        }
+
+        const config: LoginConfig = {
+          serverUrl: (serverUrl ?? savedConfig.serverUrl)!,
+          email: (email ?? savedConfig.email)!,
+          username: (username ?? savedConfig.username)!,
+          domain: domain ?? savedConfig.domain ?? "corp",
+        };
+
+        if (!config.serverUrl || !config.email || !config.username) {
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                success: false,
+                error: "Missing required fields."
+                  + " Provide serverUrl, email, and username, or"
+                  + " login once with all fields first.",
+              }),
+            }],
+          };
+        }
+
+        config.serverUrl = config.serverUrl.replace(/\/+$/, "");
+
+        const client = new EwsClient(config, password);
+        const result = await client.verifyConnection();
+
+        if (!result.ok) {
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                success: false,
+                error: result.error ?? "Connection verification failed",
+              }),
+            }],
+          };
+        }
+
+        saveConfig(config);
+
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              success: true,
+              message: `Logged in as ${email} to ${serverUrl}`,
+            }),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              success: false,
+              error: error.message ?? String(error),
+            }),
+          }],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "check_session",
+    {
+      description:
+        "Check whether the current EWS session is authenticated. No parameters. Returns {authenticated, email, serverUrl} or {authenticated, error}.",
+      inputSchema: z.object({}),
+    },
+    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();
+
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              authenticated: result.ok,
+              email: config.email,
+              serverUrl: config.serverUrl,
+              error: result.error,
+            }),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              authenticated: false,
+              error: error.message ?? String(error),
+            }),
+          }],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "logout",
+    {
+      description:
+        "Clear stored credentials (serverUrl, email, username, domain, password). No parameters. Returns {success, message}.",
+      inputSchema: z.object({}),
+    },
+    async () => {
+      clearConfig();
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({
+            success: true,
+            message: "Logged out. Credentials cleared.",
+          }),
+        }],
+      };
+    },
+  );
+}

tools/availability.ts

@@ -0,0 +1,333 @@
+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. Queries your free/busy status and returns available slots within working hours that meet the minimum duration. Returns {freeSlots: {date: [{start, end, durationMinutes}]}}. Defaults: durationMinutes=30, startHour=9, endHour=18.",
+      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 common free time for multiple attendees. Queries free/busy for all attendees and returns slots where everyone is available. Returns {period, attendees, freeSlots}. Defaults: durationMinutes=30, startHour=9, endHour=18.",
+      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

@@ -0,0 +1,188 @@
+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. Set includeBody=true to fetch organizer, attendees, and body via GetItem. Returns {events, count}.",
+      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. Default: false",
+        ),
+      }),
+    },
+    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. Inline (embedded) attachments are skipped — only standalone file attachments are downloaded. Returns {success, downloaded, count} or {success, downloaded, count, errors}.",
+      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

@@ -0,0 +1,368 @@
+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";
+
+function getClient(): EwsClient {
+  return new EwsClient(loadConfig());
+}
+
+export function registerEmailTools(server: McpServer): void {
+  server.registerTool(
+    "get_emails",
+    {
+      description:
+        "Get emails from a mailbox folder. Supports optional text search via query/queryScope. Returns {emails, count} or {itemIds, count} if idsOnly. Defaults: folder=Inbox, limit=10, offset=0, includeBody=false, unreadOnly=false, idsOnly=false, queryScope=all. Note: idsOnly raises the limit to 500.",
+      inputSchema: z.object({
+        folder: z.string().default("Inbox").describe(
+          "Folder name (Inbox, Sent, Drafts, Deleted, Junk, or custom). Supports Russian folder names",
+        ),
+        limit: z.number().default(10).describe(
+          "Maximum number of emails to return. Default: 10. Max 50 (max 500 if idsOnly=true)",
+        ),
+        offset: z.number().default(0).describe(
+          "Number of emails to skip for pagination. Default: 0",
+        ),
+        includeBody: z.boolean().default(false).describe(
+          "If true, fetches full email body for each email (slower). Default: false",
+        ),
+        unreadOnly: z.boolean().default(false).describe(
+          "If true, only return unread emails. Default: false",
+        ),
+        idsOnly: z.boolean().default(false).describe(
+          "If true, return only item IDs, dates, and subjects — faster with higher limit of 500. Default: false",
+        ),
+        query: z.string().optional().describe(
+          "Optional text to search for within the folder",
+        ),
+        queryScope: z.enum(["all", "subject", "body", "from"]).default("all")
+          .describe(
+            "Scope for text search. Values: all (subject+body), subject, body, from. Only used when query is set. Default: all",
+          ),
+      }),
+    },
+    async (
+      {
+        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;
+
+        const restrictions: string[] = [];
+
+        if (unreadOnly) {
+          restrictions.push(`\
+        <t:IsEqualTo>
+          <t:FieldURI FieldURI="message:IsRead"/>
+          <t:FieldURIOrConstant>
+            <t:Constant Value="false"/>
+          </t:FieldURIOrConstant>
+        </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>`;
+        }
+
+        const items = await client.findItems(folderId, {
+          limit,
+          offset,
+          baseShape,
+          restriction,
+        });
+
+        if (idsOnly) {
+          const result = items.map((item: any) => ({
+            itemId: item.ItemId?.["@_Id"] ?? "",
+            date: item.DateTimeReceived ?? "",
+            subject: item.Subject ?? "",
+          }));
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({ itemIds: result, count: result.length }),
+            }],
+          };
+        }
+
+        const emails = [];
+        for (const item of items) {
+          const email = client.extractEmailSummary(item);
+
+          if (includeBody && email.itemId) {
+            const details = client.extractEmailDetails(item);
+            email.to = details.to;
+            email.cc = details.cc;
+            email.body = details.body;
+            email.hasLinks = details.hasLinks;
+          }
+
+          emails.push(email);
+        }
+
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({ emails, count: emails.length }),
+          }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({ error: error.message ?? String(error) }),
+          }],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "get_email",
+    {
+      description:
+        "Get a single email with full body and details by Exchange ItemId. Returns the full Email object (subject, from, to, cc, body, date, attachments, etc.).",
+      inputSchema: z.object({
+        itemId: z.string().describe(
+          "The Exchange ItemId of the email to retrieve",
+        ),
+      }),
+    },
+    async ({ itemId }) => {
+      try {
+        const client = getClient();
+        const item = await client.getItem(itemId);
+        const email = client.extractEmailDetails(item);
+
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify(email) }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({ error: error.message ?? String(error) }),
+          }],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "mark_email_read",
+    {
+      description:
+        "Mark one or more emails as read or unread by their Exchange ItemIds. Returns {success, message} or {error}.",
+      inputSchema: z.object({
+        itemIds: z.array(z.string()).describe(
+          "List of Exchange ItemIds to update",
+        ),
+        isRead: z.boolean().default(true).describe(
+          "True to mark as read, false to mark as unread. Default: true",
+        ),
+      }),
+    },
+    async ({ itemIds, isRead }) => {
+      try {
+        const client = new EwsClient(loadConfig());
+        const responses = await client.updateItems(itemIds, [
+          { fieldUri: "message:IsRead", value: isRead },
+        ]);
+
+        const errors = responses
+          .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. Inline (embedded) attachments are skipped — only standalone file attachments are downloaded. Returns {success, downloaded, count} or {success, downloaded, count, errors}.",
+      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,
+                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/folders.ts

@@ -0,0 +1,38 @@
+import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod/v4";
+import { EwsClient, loadConfig } from "../ews_client.ts";
+
+export function registerFolderTools(server: McpServer): void {
+  server.registerTool(
+    "get_folders",
+    {
+      description:
+        "List mailbox folders from the Exchange mailbox. Returns a list of Folder objects (name, id, totalCount, unreadCount, childFolderCount).",
+      inputSchema: z.object({
+        parentFolderId: z.string().default("msgfolderroot").describe(
+          "Parent folder to list children of. Supports distinguished names (e.g. inbox, calendar). Default: msgfolderroot",
+        ),
+        recursive: z.boolean().default(false).describe(
+          "If true, recursively traverse all subfolders. Default: false",
+        ),
+      }),
+    },
+    async ({ parentFolderId, recursive }) => {
+      try {
+        const client = new EwsClient(loadConfig());
+        const folders = await client.findFolders(parentFolderId, recursive);
+
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify(folders) }],
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({ error: error.message ?? String(error) }),
+          }],
+        };
+      }
+    },
+  );
+}

tools/people.ts

@@ -0,0 +1,99 @@
+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 (Active Directory) by name, email, or keyword. Returns a list of Person objects with name, email, jobTitle, department, company, office, phones, manager, directReports, and more.",
+      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) }),
+          }],
+        };
+      }
+    },
+  );
+}

tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "checkJs": false,
+    "erasableSyntaxOnly": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "keyofStringsOnly": false,
+    "lib": [
+      "esnext"
+    ],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "noEmit": true,
+    "noErrorTruncation": false,
+    "noFallthroughCasesInSwitch": false,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": false,
+    "noImplicitThis": true,
+    "noStrictGenericChecks": false,
+    "noUncheckedIndexedAccess": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "suppressExcessPropertyErrors": false,
+    "suppressImplicitAnyIndexErrors": false,
+    "target": "esnext",
+    "types": [
+      "node"
+    ],
+    "useUnknownInCatchVariables": true,
+    "verbatimModuleSyntax": true
+  }
+}

types/calendar_event.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,32 @@
+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

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

types/free_slot.ts

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

types/login_config.ts

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

types/meeting_result.ts

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

types/person.ts

@@ -0,0 +1,17 @@
+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 }>;
+}