w

.gitignore

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

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

@@ -1,19 +1,31 @@
 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 { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { initDataDir } from "../utils/data.ts";
+import type { Email } from "./types/email.ts";
-import { type Email, extractEmail } from "../utils/extract_email.ts";
+import type { Folder } from "./types/folder.ts";
-import { extractFolders, type Folder } from "../utils/extract_folder.ts";
+import type { LoginConfig } from "./types/login_config.ts";
-import {
+
-  clearConfig,
+let inMemoryPassword: string | null = null;
-  getPassword,
+
-  hasPassword,
+export function setPassword(password: string): void {
-  loadConfig,
+  inMemoryPassword = password;
-  type LoginConfig,
+}
-  saveConfig,
+
-  setPassword,
+export function getPassword(): string | null {
-} from "../utils/login.ts";
+  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));
@@ -26,6 +38,13 @@ const AGENT = new https.Agent({
   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",
@@ -54,12 +73,31 @@ ${body}
 </s:Envelope>`;
 }
 
-const PARSER = new XMLParser({
+function configFilePath(): string {
-  ignoreAttributes: false,
+  const dir = path.dirname(fileURLToPath(import.meta.url));
-  attributeNamePrefix: "@_",
+  return path.join(dir, "config.json");
-  removeNSPrefix: true,
+}
-  textNodeName: "#text",
+
-});
+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;
@@ -68,7 +106,10 @@ export class EwsClient {
   constructor(config: LoginConfig, password?: string) {
     this.config = config;
     this.ewsUrl = `${config.serverUrl.replace(/\/+$/, "")}/EWS/Exchange.asmx`;
-    if (password) setPassword(password);
+
+    if (password) {
+      setPassword(password);
+    }
   }
 
   private get domain(): string {
@@ -99,7 +140,8 @@ export class EwsClient {
       throw new Error(`NTLM request failed, status=${res.statusCode}`);
     }
 
-    return PARSER.parse(res.body);
+    const parsed = PARSER.parse(res.body);
+    return parsed;
   }
 
   private extractResponseMessages(data: any): any[] {
@@ -130,8 +172,7 @@ export class EwsClient {
 
   async getFolderId(folderName: string): Promise<string> {
     const lower = folderName.toLowerCase();
-    const distinguished =
+    const distinguished = DISTINGUISHED_FOLDERS[lower];
-      (DISTINGUISHED_FOLDERS as Record<string, string>)[lower];
 
     if (distinguished) {
       const soap = buildSoapEnvelope(`\
@@ -205,14 +246,6 @@ export class EwsClient {
       traversal = "Shallow",
     } = options;
 
-    const isDistinguished =
-      (DISTINGUISHED_FOLDERS as Record<string, string>)[folderId.toLowerCase()]
-        !== undefined;
-
-    const folderIdXml = isDistinguished
-      ? `<t:DistinguishedFolderId Id="${folderId}"/>`
-      : `<t:FolderId Id="${folderId}"/>`;
-
     const soap = buildSoapEnvelope(`\
     <m:FindItem Traversal="${traversal}">
       <m:ItemShape>
@@ -220,7 +253,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">
@@ -287,200 +320,203 @@ ${restriction}
     parentFolderId: string,
     recursive: boolean = false,
   ): Promise<Folder[]> {
-    return extractFolders(
+    const traversal = recursive ? "Deep" : "Shallow";
-      (body, soapAction) => this.soapRequest(body, soapAction),
+    const isDistinguished =
-      parentFolderId,
+      DISTINGUISHED_FOLDERS[parentFolderId.toLowerCase()] !== undefined
-      recursive,
+      || ["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;
   }
 
-  extractEmail(item: any): Email {
+  extractEmailSummary(item: any): Email {
-    return extractEmail(item);
+    const itemType = item["@_xsi_type"] ?? item.__type ?? "";
-  }
+    const isMeeting =
+      /MeetingRequest|MeetingResponse|MeetingCancellation|CalendarItem/i.test(
+        itemType,
+      );
 
-  async updateItems(
+    const fromMailbox = item.From?.Mailbox
-    itemIds: string[],
+      ?? item.Organizer?.Mailbox
-    updates: { fieldUri: string; value: string | boolean }[],
+      ?? item.Sender?.Mailbox
-  ): Promise<any[]> {
+      ?? {};
-    const propName = (fieldUri: string): string => {
+
-      const parts = fieldUri.split(":");
+    const email: Email = {
-      return parts[parts.length - 1];
+      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 ?? "",
     };
 
-    const changesXml = itemIds.map((id) => {
+    if (item.DisplayTo) {
-      const updatesXml = updates.map((u) => {
+      email.to = item.DisplayTo.split(";").map((t: string) => t.trim()).filter(
-        const val = typeof u.value === "boolean"
+        Boolean,
-          ? (u.value ? "true" : "false")
+      );
-          : u.value;
+    }
-        return `\
+    if (item.DisplayCc) {
-            <t:SetItemField>
+      email.cc = item.DisplayCc.split(";").map((c: string) => c.trim()).filter(
-              <t:FieldURI FieldURI="${u.fieldUri}"/>
+        Boolean,
-              <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);
-  }
-
-  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`);
+    if (isMeeting) {
-  }
+      email.location = item.Location ?? "";
-
+      email.start = item.Start ?? item.StartWallClock ?? item.ReminderDueBy
-  async findCalendarItems(
+        ?? "";
-    folderId: string,
+      email.end = item.End ?? item.EndWallClock ?? "";
-    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 [];
+    return email;
   }
 
-  async getUserAvailability(
+  extractEmailDetails(item: any): Email {
-    emails: string[],
+    const email = this.extractEmailSummary(item);
-    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"?>
+    const bodyVal = item.Body?.Value ?? item.Body?.["#text"] ?? "";
-<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
+    const bodyType = item.Body?.["@_BodyType"] ?? item.Body?.BodyType ?? "Text";
-  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(
+    if (bodyType === "HTML") {
-      soap,
+      email.hasLinks = /<a\s/i.test(bodyVal);
-      "http://schemas.microsoft.com/exchange/services/2006/messages/GetUserAvailability",
+      email.body = this.htmlToText(bodyVal);
-    );
+    } else {
+      email.body = bodyVal;
+    }
+    email.bodyType = bodyType;
 
-    return data;
+    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);
 
-  async resolveNames(
+    const ccRecipients = item.CcRecipients?.Mailbox ?? [];
-    query: string,
+    email.cc = (Array.isArray(ccRecipients) ? ccRecipients : [ccRecipients])
-    fullContact: boolean = true,
+      .map((r: any) => {
-  ): Promise<any[]> {
+        const name = r.Name ?? "";
-    const soap = buildSoapEnvelope(`\
+        const addr = r.EmailAddress ?? "";
-    <m:ResolveNames ReturnFullContactData="${fullContact}" SearchScope="ActiveDirectoryContacts">
+        return name && addr ? `${name} <${addr}>` : addr;
-      <m:UnresolvedEntry>${
+      })
-      query.replace(/&/g, "&amp;").replace(/</g, "&lt;")
+      .filter(Boolean);
-    }</m:UnresolvedEntry>
-    </m:ResolveNames>`);
 
-    const data = await this.soapRequest(
+    const attachments = item.Attachments?.FileAttachment ?? [];
-      soap,
+    const attList = Array.isArray(attachments) ? attachments : [attachments];
-      "http://schemas.microsoft.com/exchange/services/2006/messages/ResolveNames",
+    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,
+      }));
 
-    for (const msg of this.extractResponseMessages(data)) {
+    const isMeeting =
-      const resolutions = msg?.ResolutionSet?.Resolution;
+      /MeetingRequest|MeetingResponse|MeetingCancellation|CalendarItem/i.test(
-      if (resolutions) {
+        item["@_xsi_type"] ?? "",
-        return Array.isArray(resolutions) ? resolutions : [resolutions];
+      );
-      }
+    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 [];
+    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();
   }
 }

main.ts

@@ -5,12 +5,8 @@ import { Command } from "commander";
 import crypto from "node:crypto";
 import http from "node:http";
 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";
-import { initDataDir } from "./utils/data.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;
 }

tools/auth.ts

@@ -1,69 +1,38 @@
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod/v4";
-import { EwsClient } from "../client/ews_client.ts";
 import {
   clearConfig,
+  EwsClient,
   hasPassword,
   loadConfig,
   saveConfig,
   setPassword,
-} from "../utils/login.ts";
+} from "../ews_client.ts";
-import { type LoginConfig } from "../utils/login.ts";
 
 export function registerAuthTools(server: McpServer): void {
   server.registerTool(
     "login",
     {
-      description: "Authenticate to Exchange EWS using NTLM credentials."
+      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.",
       inputSchema: z.object({
-        serverUrl: z.string().optional().describe("EWS server URL"),
+        serverUrl: z.string().describe(
-        email: z.string().optional().describe("Email address"),
+          "EWS server URL (e.g. https://mail.example.com)",
-        username: z.string().optional().describe("NTLM username"),
+        ),
+        email: z.string().describe("Email address"),
+        username: z.string().describe("NTLM username"),
         password: z.string().describe("NTLM password"),
-        domain: z.string().optional().describe("NTLM domain"),
+        domain: z.string().optional().describe("NTLM domain (default: corp)"),
-      }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string().optional(),
-        error: z.string().optional(),
       }),
     },
     async ({ serverUrl, email, username, password, domain }) => {
       try {
-        let savedConfig: Partial<LoginConfig> = {};
+        const config = {
-        try {
+          serverUrl: serverUrl.replace(/\/+$/, ""),
-          savedConfig = loadConfig();
+          email,
-        } catch {
+          username,
-          // no saved config — all fields must be provided
+          domain: domain ?? "corp",
-        }
-
-        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();
 
@@ -107,15 +76,8 @@ export function registerAuthTools(server: McpServer): void {
   server.registerTool(
     "check_session",
     {
-      description:
+      description: "Check whether the current EWS session is authenticated",
-        "Check whether the current EWS session is authenticated. No parameters.",
       inputSchema: z.object({}),
-      outputSchema: z.object({
-        authenticated: z.boolean(),
-        email: z.string().optional(),
-        serverUrl: z.string().optional(),
-        error: z.string().optional(),
-      }),
     },
     async () => {
       try {
@@ -128,10 +90,6 @@ export function registerAuthTools(server: McpServer): void {
                 error: "Not logged in. Password not found in memory.",
               }),
             }],
-            structuredContent: {
-              authenticated: false,
-              error: "Not logged in. Password not found in memory.",
-            },
           };
         }
         const config = loadConfig();
@@ -148,12 +106,6 @@ export function registerAuthTools(server: McpServer): void {
               error: result.error,
             }),
           }],
-          structuredContent: {
-            authenticated: result.ok,
-            email: config.email,
-            serverUrl: config.serverUrl,
-            error: result.error,
-          },
         };
       } catch (error: any) {
         return {
@@ -164,10 +116,6 @@ export function registerAuthTools(server: McpServer): void {
               error: error.message ?? String(error),
             }),
           }],
-          structuredContent: {
-            authenticated: false,
-            error: error.message ?? String(error),
-          },
         };
       }
     },
@@ -176,14 +124,8 @@ export function registerAuthTools(server: McpServer): void {
   server.registerTool(
     "logout",
     {
-      description:
+      description: "Clear stored credentials",
-        "Clear stored credentials (serverUrl, email, username, domain, password)."
-        + " No parameters.",
       inputSchema: z.object({}),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string().optional(),
-      }),
     },
     async () => {
       clearConfig();
@@ -195,10 +137,6 @@ export function registerAuthTools(server: McpServer): void {
             message: "Logged out. Credentials cleared.",
           }),
         }],
-        structuredContent: {
-          success: true,
-          message: "Logged out. Credentials cleared.",
-        },
       };
     },
   );

tools/availability.ts

@@ -1,372 +0,0 @@
-import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod/v4";
-import { EwsClient } from "../client/ews_client.ts";
-import { loadConfig } from "../utils/login.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.",
-      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",
-        ),
-        durationMinutes: z.number().default(30).describe(
-          "Minimum slot duration in minutes",
-        ),
-        startHour: z.number().default(9).describe(
-          "Working day start hour (0-23)",
-        ),
-        endHour: z.number().default(18).describe(
-          "Working day end hour (0-23)",
-        ),
-      }),
-      outputSchema: z.object({
-        freeSlots: z.record(
-          z.string(),
-          z.array(z.object({
-            start: z.string(),
-            end: z.string(),
-            durationMinutes: z.number(),
-          })),
-        ),
-      }),
-    },
-    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 }),
-          }],
-          structuredContent: { 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.",
-      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",
-        ),
-        durationMinutes: z.number().default(30).describe(
-          "Minimum slot duration in minutes",
-        ),
-        startHour: z.number().default(9).describe(
-          "Working day start hour (0-23)",
-        ),
-        endHour: z.number().default(18).describe(
-          "Working day end hour (0-23)",
-        ),
-      }),
-      outputSchema: z.object({
-        period: z.object({
-          start: z.string(),
-          end: z.string(),
-        }),
-        attendees: z.array(z.object({
-          email: z.string(),
-          busySlots: z.number().optional(),
-          freeSlots: z.number().optional(),
-          calendarEvents: z.number().optional(),
-        })),
-        freeSlots: z.record(
-          z.string(),
-          z.array(z.object({
-            start: z.string(),
-            end: z.string(),
-            durationMinutes: z.number(),
-          })),
-        ),
-      }),
-    },
-    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,
-            }),
-          }],
-          structuredContent: {
-            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,237 +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 } from "../client/ews_client.ts";
-import { loadConfig } from "../utils/login.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.",
-      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",
-        ),
-      }),
-      outputSchema: z.object({
-        events: z.array(z.object({
-          subject: z.string(),
-          start: z.string(),
-          end: z.string(),
-          location: z.string(),
-          isAllDay: z.boolean(),
-          isCancelled: z.boolean(),
-          isMeeting: z.boolean(),
-          isRecurring: z.boolean(),
-          organizer: z.string(),
-          organizerEmail: z.string(),
-          myResponse: z.string(),
-          itemId: z.string(),
-          body: z.string(),
-          requiredAttendees: z.array(z.string()),
-          optionalAttendees: z.array(z.string()),
-        })),
-        count: z.number(),
-      }),
-    },
-    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.extractEmail(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 }),
-          }],
-          structuredContent: { 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.",
-      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",
-        ),
-      }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        downloaded: z.array(z.object({
-          name: z.string(),
-          path: z.string(),
-          size: z.number(),
-          contentType: z.string(),
-        })),
-        count: z.number(),
-        errors: z.array(z.object({
-          name: z.string(),
-          error: z.string(),
-        })).optional(),
-        message: z.string().optional(),
-      }),
-    },
-    async ({ itemId, targetFolder }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const item = await client.getItem(itemId);
-        const email = client.extractEmail(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.",
-              }),
-            }],
-            structuredContent: {
-              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 } : {}),
-            }),
-          }],
-          structuredContent: errors.length === 0
-            ? { success: true, downloaded, count: downloaded.length }
-            : { success: false, downloaded, count: downloaded.length, errors },
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-}

tools/email.ts

@@ -1,9 +1,6 @@
 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 } from "../client/ews_client.ts";
+import { EwsClient, loadConfig } from "../ews_client.ts";
-import { loadConfig } from "../utils/login.ts";
 
 function getClient(): EwsClient {
   return new EwsClient(loadConfig());
@@ -13,122 +10,48 @@ export function registerEmailTools(server: McpServer): void {
   server.registerTool(
     "get_emails",
     {
-      description: "Get emails from a mailbox folder."
+      description: "Get emails from a mailbox folder",
-        + " Supports optional text search via query/queryScope.",
       inputSchema: z.object({
         folder: z.string().default("Inbox").describe(
-          "Folder name (Inbox, Sent, Drafts, Deleted, Junk, or custom)."
+          "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",
+          "Maximum number of emails to return (default 10, max 50)",
         ),
         offset: z.number().default(0).describe(
           "Number of emails to skip for pagination",
         ),
         includeBody: z.boolean().default(false).describe(
-          "If true, fetches full email body for each email (slower)",
+          "If True, fetch full body for each email (slower)",
         ),
         unreadOnly: z.boolean().default(false).describe(
-          "If true, only return unread emails",
+          "If True, only return unread emails",
         ),
-        query: z.string().optional().describe(
+        idsOnly: z.boolean().default(false).describe(
-          "Optional text to search for within the folder",
+          "If True, return only item IDs and dates (max limit 500)",
         ),
-        queryScope: z.enum(["all", "subject", "body", "from"]).default("all")
-          .describe("Search scope: all, subject, body, or from"),
-      }),
-      outputSchema: z.object({
-        emails: z.array(z.object({
-          itemId: z.string(),
-          subject: z.string(),
-          from: z.string(),
-          date: z.string(),
-          isRead: z.boolean(),
-          hasAttachments: z.boolean(),
-        })),
-        count: z.number(),
       }),
     },
-    async (
+    async ({ folder, limit, offset, includeBody, unreadOnly, idsOnly }) => {
-      {
-        folder,
-        limit,
-        offset,
-        includeBody,
-        unreadOnly,
-        query,
-        queryScope,
-      },
-    ) => {
       try {
         const client = getClient();
-        const maxLimit = 50;
+        const maxLimit = idsOnly ? 500 : 50;
         if (limit > maxLimit) limit = maxLimit;
-        offset = Math.max(0, offset);
 
         const folderId = await client.getFolderId(folder);
-        const baseShape = "AllProperties";
+        const baseShape = idsOnly ? "IdOnly" : "AllProperties";
-
-        if (query && !query.trim()) query = undefined;
-
-        const restrictions: string[] = [];
 
+        let restriction = "";
         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>
-        }
+      </m:Restriction>`;
-
-        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, {
@@ -138,9 +61,33 @@ export function registerEmailTools(server: McpServer): void {
           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) {
-          emails.push(client.extractEmail(item));
+          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 {
@@ -148,7 +95,6 @@ export function registerEmailTools(server: McpServer): void {
             type: "text" as const,
             text: JSON.stringify({ emails, count: emails.length }),
           }],
-          structuredContent: { emails, count: emails.length },
         };
       } catch (error: any) {
         return {
@@ -164,43 +110,21 @@ export function registerEmailTools(server: McpServer): void {
   server.registerTool(
     "get_email",
     {
-      description:
+      description: "Get a single email with full body and details",
-        "Get a single email with full body and details by Exchange ItemId.",
       inputSchema: z.object({
         itemId: z.string().describe(
           "The Exchange ItemId of the email to retrieve",
         ),
       }),
-      outputSchema: z.object({
-        itemId: z.string(),
-        subject: z.string(),
-        from: z.string(),
-        fromName: z.string().optional(),
-        to: z.array(z.string()).optional(),
-        cc: z.array(z.string()).optional(),
-        date: z.string(),
-        body: z.string().optional(),
-        isRead: z.boolean().optional(),
-        hasAttachments: z.boolean().optional(),
-        hasLinks: z.boolean().optional(),
-        attachments: z.array(z.object({
-          name: z.string(),
-          size: z.number(),
-          contentType: z.string(),
-          attachmentId: z.string().optional(),
-          isInline: z.boolean().optional(),
-        })).optional(),
-      }),
     },
     async ({ itemId }) => {
       try {
         const client = getClient();
         const item = await client.getItem(itemId);
-        const email = client.extractEmail(item);
+        const email = client.extractEmailDetails(item);
 
         return {
           content: [{ type: "text" as const, text: JSON.stringify(email) }],
-          structuredContent: { emails: [email] },
         };
       } catch (error: any) {
         return {
@@ -214,194 +138,143 @@ export function registerEmailTools(server: McpServer): void {
   );
 
   server.registerTool(
-    "mark_email_read",
+    "search_emails",
     {
-      description:
+      description: "Search emails by text across one or all folders",
-        "Mark one or more emails as read or unread by their Exchange ItemIds.",
       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")
-      outputSchema: z.object({
+          .describe("Where to search"),
-        success: z.boolean(),
-        message: z.string().optional(),
-        error: z.string().optional(),
       }),
     },
-    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("; ") }),
-            }],
-            structuredContent: {
-              success: false,
-              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}.`,
-            }),
-          }],
-          structuredContent: {
-            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) }),
-          }],
-          structuredContent: {
-            success: false,
-            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.",
-      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",
-        ),
-      }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        downloaded: z.array(z.object({
-          name: z.string(),
-          path: z.string(),
-          size: z.number(),
-          contentType: z.string(),
-        })),
-        count: z.number(),
-        errors: z.array(z.object({
-          name: z.string(),
-          error: z.string(),
-        })).optional(),
-        message: z.string().optional(),
-      }),
-    },
-    async ({ itemId, targetFolder }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const item = await client.getItem(itemId);
-        const email = client.extractEmail(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.",
               }),
             }],
-            structuredContent: {
-              success: true,
-              downloaded: [],
-              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 {
-          structuredContent: errors.length === 0
+          const fieldUri = fieldUriMap[searchScope];
-            ? { success: true, downloaded, count: downloaded.length }
+          if (!fieldUri) {
-            : { success: false, downloaded, count: downloaded.length, errors },
+            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: [{
@@ -413,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/folders.ts

@@ -1,31 +1,20 @@
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod/v4";
-import { EwsClient } from "../client/ews_client.ts";
+import { EwsClient, loadConfig } from "../ews_client.ts";
-import { loadConfig } from "../utils/login.ts";
 
 export function registerFolderTools(server: McpServer): void {
   server.registerTool(
     "get_folders",
     {
-      description: "List mailbox folders from the Exchange mailbox.",
+      description: "List mail folders from the Exchange mailbox",
       inputSchema: z.object({
         parentFolderId: z.string().default("msgfolderroot").describe(
-          "Parent folder to list children of."
+          "Parent folder to list children of (default: msgfolderroot)",
-            + " Supports distinguished names (e.g. inbox, calendar)",
         ),
         recursive: z.boolean().default(false).describe(
-          "If true, recursively traverse all subfolders",
+          "If True, traverse all subfolders recursively",
         ),
       }),
-      outputSchema: z.object({
-        folders: z.array(z.object({
-          name: z.string(),
-          id: z.string(),
-          totalCount: z.number(),
-          unreadCount: z.number(),
-          childFolderCount: z.number(),
-        })),
-      }),
     },
     async ({ parentFolderId, recursive }) => {
       try {
@@ -34,7 +23,6 @@ export function registerFolderTools(server: McpServer): void {
 
         return {
           content: [{ type: "text" as const, text: JSON.stringify(folders) }],
-          structuredContent: { folders },
         };
       } catch (error: any) {
         return {

tools/people.ts

@@ -1,122 +0,0 @@
-import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod/v4";
-import { EwsClient } from "../client/ews_client.ts";
-import { loadConfig } from "../utils/login.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.",
-      inputSchema: z.object({
-        query: z.string().describe(
-          "Name, email address, or keyword to search for",
-        ),
-      }),
-      outputSchema: z.object({
-        name: z.string(),
-        email: z.string(),
-        mailboxType: z.string(),
-        firstName: z.string(),
-        lastName: z.string(),
-        jobTitle: z.string(),
-        department: z.string(),
-        company: z.string(),
-        office: z.string(),
-        alias: z.string(),
-        manager: z.string(),
-        managerEmail: z.string(),
-        phones: z.record(z.string(), z.string()),
-        address: z.string(),
-        directReports: z.array(z.object({
-          name: z.string(),
-          email: z.string(),
-        })),
-      }),
-    },
-    async ({ query }) => {
-      try {
-        const client = new EwsClient(loadConfig());
-        const resolutions = await client.resolveNames(query);
-
-        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) }],
-          structuredContent: { people },
-        };
-      } catch (error: any) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({ error: error.message ?? String(error) }),
-          }],
-        };
-      }
-    },
-  );
-}

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 }>;
+}

utils/data.ts

@@ -1,13 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-let dataDir: string = "./data";
-
-export function initDataDir(dir: string): void {
-  dataDir = path.resolve(dir);
-  fs.mkdirSync(dataDir, { recursive: true });
-}
-
-export function configFilePath(): string {
-  return path.join(dataDir, "config.json");
-}

utils/extract_email.ts

@@ -1,156 +0,0 @@
-import { htmlToText } from "./html_to_text.ts";
-
-export interface Attachment {
-  name: string;
-  size: number;
-  contentType: string;
-  attachmentId: string;
-  isInline: boolean;
-}
-
-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 function extractEmail(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 ?? "";
-  }
-
-  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 = 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,
-    }));
-
-  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;
-}

utils/extract_folder.ts

@@ -1,101 +0,0 @@
-export interface Folder {
-  name: string;
-  id: string;
-  totalCount: number;
-  unreadCount: number;
-  childFolderCount: number;
-}
-
-type SoapRequest = (body: string, soapAction: string) => Promise<any>;
-
-export async function extractFolders(
-  soapRequest: SoapRequest,
-  parentFolderId: string,
-  recursive: boolean = false,
-): Promise<Folder[]> {
-  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 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];
-  }
-
-  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 soapRequest(
-    soap,
-    "http://schemas.microsoft.com/exchange/services/2006/messages/FindFolder",
-  );
-
-  const folders: Folder[] = [];
-
-  for (const msg of 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;
-}

utils/html_to_text.ts

@@ -1,20 +0,0 @@
-export function 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();
-}

utils/login.ts

@@ -1,51 +0,0 @@
-import fs from "node:fs";
-import { configFilePath, initDataDir } from "./data.ts";
-
-// Re-export for backward compatibility
-export { initDataDir };
-
-export interface LoginConfig {
-  serverUrl: string;
-  email: string;
-  username: string;
-  domain?: string;
-}
-
-let inMemoryPassword: string | null = null;
-
-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;
-}
-
-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();
-}