@atengk/mcp-server-email 0.0.0-stage → 1.0.1

package/dist/index.js

@@ -0,0 +1,1867 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import http from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config/index.ts
+import fs from "fs";
+import path from "path";
+import dotenv from "dotenv";
+import { z } from "zod";
+dotenv.config();
+var smtpProfileSchema = z.object({
+  host: z.string(),
+  port: z.union([z.number(), z.string().transform((val) => parseInt(val, 10))]).default(465),
+  secure: z.union([z.boolean(), z.string().transform((val) => val === "true" || val === "1")]).default(true),
+  user: z.string(),
+  pass: z.string(),
+  from: z.string().optional()
+});
+var imapProfileSchema = z.object({
+  host: z.string(),
+  port: z.union([z.number(), z.string().transform((val) => parseInt(val, 10))]).default(993),
+  secure: z.union([z.boolean(), z.string().transform((val) => val === "true" || val === "1")]).default(true),
+  user: z.string(),
+  pass: z.string()
+});
+var accountProfileSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  email: z.string().optional(),
+  smtp: smtpProfileSchema.optional(),
+  imap: imapProfileSchema.optional()
+});
+var envSchema = z.object({
+  // SMTP 配置 (向下兼容单账户)
+  MCP_SMTP_HOST: z.string().optional(),
+  MCP_SMTP_PORT: z.string().optional().transform((val) => val ? parseInt(val, 10) : 465),
+  MCP_SMTP_SECURE: z.string().optional().transform((val) => val === void 0 || val === "true" || val === "1"),
+  MCP_SMTP_USER: z.string().optional(),
+  MCP_SMTP_PASS: z.string().optional(),
+  MCP_SMTP_FROM: z.string().optional(),
+  // IMAP 配置 (向下兼容单账户)
+  MCP_IMAP_HOST: z.string().optional(),
+  MCP_IMAP_PORT: z.string().optional().transform((val) => val ? parseInt(val, 10) : 993),
+  MCP_IMAP_SECURE: z.string().optional().transform((val) => val === void 0 || val === "true" || val === "1"),
+  MCP_IMAP_USER: z.string().optional(),
+  MCP_IMAP_PASS: z.string().optional(),
+  // 多账户配置
+  MCP_ACCOUNTS: z.string().optional(),
+  MCP_ACCOUNTS_FILE: z.string().optional(),
+  MCP_DEFAULT_ACCOUNT: z.string().optional(),
+  // MCP 传输与服务配置
+  MCP_TRANSPORT: z.enum(["stdio", "sse"]).default("stdio"),
+  MCP_PORT: z.string().optional().transform((val) => val ? parseInt(val, 10) : 3e3),
+  MCP_LOG_LEVEL: z.string().default("info")
+});
+function parseAccountsFromJson(raw) {
+  if (Array.isArray(raw)) {
+    return z.array(accountProfileSchema).parse(raw);
+  }
+  if (typeof raw === "object" && raw !== null) {
+    const record = z.record(accountProfileSchema.omit({ id: true })).parse(raw);
+    return Object.entries(record).map(([id, profile]) => ({
+      ...profile,
+      id
+    }));
+  }
+  throw new Error("\u65E0\u6548\u7684\u8D26\u6237\u914D\u7F6E\u683C\u5F0F\uFF0C\u5FC5\u987B\u4E3A JSON \u6570\u7EC4\u6216\u952E\u503C\u5BF9\u8C61");
+}
+function parseAccountProfiles(env = process.env) {
+  let accounts = [];
+  const accountsFile = env.MCP_ACCOUNTS_FILE;
+  if (accountsFile) {
+    try {
+      const resolvedPath = path.isAbsolute(accountsFile) ? accountsFile : path.resolve(process.cwd(), accountsFile);
+      if (fs.existsSync(resolvedPath)) {
+        const fileContent = fs.readFileSync(resolvedPath, "utf-8");
+        accounts = parseAccountsFromJson(JSON.parse(fileContent));
+      } else {
+        console.error(`[\u914D\u7F6E\u8B66\u544A] MCP_ACCOUNTS_FILE \u6307\u5B9A\u7684\u6587\u4EF6\u4E0D\u5B58\u5728: ${resolvedPath}`);
+      }
+    } catch (err) {
+      console.error(
+        "[\u914D\u7F6E\u9519\u8BEF] \u89E3\u6790 MCP_ACCOUNTS_FILE \u5931\u8D25:",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  const accountsJson = env.MCP_ACCOUNTS;
+  if (accountsJson && accounts.length === 0) {
+    try {
+      accounts = parseAccountsFromJson(JSON.parse(accountsJson));
+    } catch (err) {
+      console.error(
+        "[\u914D\u7F6E\u9519\u8BEF] \u89E3\u6790 MCP_ACCOUNTS JSON \u5931\u8D25:",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  if (accounts.length === 0) {
+    const hasSmtp = Boolean(env.MCP_SMTP_HOST && env.MCP_SMTP_USER && env.MCP_SMTP_PASS);
+    const hasImap = Boolean(env.MCP_IMAP_HOST && env.MCP_IMAP_USER && env.MCP_IMAP_PASS);
+    if (hasSmtp || hasImap) {
+      const defaultAccount = {
+        id: "default",
+        name: "\u9ED8\u8BA4\u90AE\u7BB1\u8D26\u6237",
+        email: env.MCP_SMTP_USER || env.MCP_IMAP_USER
+      };
+      if (hasSmtp) {
+        defaultAccount.smtp = {
+          host: env.MCP_SMTP_HOST,
+          port: env.MCP_SMTP_PORT ? parseInt(env.MCP_SMTP_PORT, 10) : 465,
+          secure: env.MCP_SMTP_SECURE === void 0 || env.MCP_SMTP_SECURE === "true" || env.MCP_SMTP_SECURE === "1",
+          user: env.MCP_SMTP_USER,
+          pass: env.MCP_SMTP_PASS,
+          from: env.MCP_SMTP_FROM
+        };
+      }
+      if (hasImap) {
+        defaultAccount.imap = {
+          host: env.MCP_IMAP_HOST,
+          port: env.MCP_IMAP_PORT ? parseInt(env.MCP_IMAP_PORT, 10) : 993,
+          secure: env.MCP_IMAP_SECURE === void 0 || env.MCP_IMAP_SECURE === "true" || env.MCP_IMAP_SECURE === "1",
+          user: env.MCP_IMAP_USER,
+          pass: env.MCP_IMAP_PASS
+        };
+      }
+      accounts.push(defaultAccount);
+    }
+  }
+  let defaultAccountId = env.MCP_DEFAULT_ACCOUNT || "";
+  if (!defaultAccountId || !accounts.some((a) => a.id === defaultAccountId)) {
+    const defaultAcc = accounts.find((a) => a.id === "default");
+    defaultAccountId = defaultAcc ? defaultAcc.id : accounts[0]?.id || "default";
+  }
+  return { accounts, defaultAccountId };
+}
+function loadConfig(env = process.env) {
+  const result = envSchema.safeParse(env);
+  if (!result.success) {
+    console.error("[\u914D\u7F6E\u9519\u8BEF] \u73AF\u5883\u53D8\u91CF\u6821\u9A8C\u5931\u8D25:", result.error.format());
+    throw new Error("\u73AF\u5883\u53D8\u91CF\u683C\u5F0F\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5 .env \u914D\u7F6E");
+  }
+  const { accounts, defaultAccountId } = parseAccountProfiles(env);
+  return {
+    ...result.data,
+    accounts,
+    defaultAccountId
+  };
+}
+var config = loadConfig();
+
+// src/tools/index.ts
+import { z as z2 } from "zod";
+
+// src/services/imap.service.ts
+import { ImapFlow } from "imapflow";
+import { simpleParser } from "mailparser";
+
+// src/services/mailbox-resolver.ts
+import nodemailer from "nodemailer";
+
+// src/services/attachment-sandbox.ts
+import fs2 from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { pathToFileURL } from "url";
+function getAttachmentSandboxDir() {
+  const customDir = process.env.MCP_ATTACHMENT_DIR;
+  if (customDir && customDir.trim().length > 0) {
+    return path2.resolve(customDir.trim());
+  }
+  return path2.resolve(os.tmpdir(), "mcp-email-attachments");
+}
+function sanitizeFileName(rawName) {
+  if (!rawName || typeof rawName !== "string") {
+    return `attachment-${Date.now()}`;
+  }
+  if (rawName.includes("..") || rawName.includes("\0")) {
+    throw new Error(`\u62D2\u7EDD\u5904\u7406\uFF1A\u68C0\u6D4B\u5230\u975E\u6CD5\u8DEF\u5F84\u7A7F\u8D8A\u6587\u4EF6\u540D "${rawName}"`);
+  }
+  const normalized = rawName.replace(/\\/g, "/");
+  let cleanName = path2.posix.basename(normalized);
+  cleanName = cleanName.replace(/[\x00-\x1f\x7f<>:"/\\|?*]/g, "_").trim();
+  if (!cleanName || cleanName === "." || cleanName === "..") {
+    cleanName = `attachment-${Date.now()}`;
+  }
+  return cleanName;
+}
+async function saveAttachmentToSandbox(rawFileName, content, customSandboxDir, uid) {
+  const sandboxDir = path2.resolve(customSandboxDir || getAttachmentSandboxDir());
+  const targetDir = uid !== void 0 ? path2.join(sandboxDir, String(uid)) : sandboxDir;
+  await fs2.mkdir(targetDir, { recursive: true });
+  const safeFileName = sanitizeFileName(rawFileName);
+  const targetPath = path2.resolve(targetDir, safeFileName);
+  const relative = path2.relative(sandboxDir, targetPath);
+  if (relative.startsWith("..") || path2.isAbsolute(relative)) {
+    throw new Error(`\u5B89\u5168\u9632\u5FA1\u89E6\u53D1\uFF1A\u76EE\u6807\u8DEF\u5F84 "${targetPath}" \u8D8A\u754C\u9003\u9038\u6C99\u7BB1\u6839\u76EE\u5F55 "${sandboxDir}"`);
+  }
+  await fs2.writeFile(targetPath, content);
+  const fileUrl = pathToFileURL(targetPath).toString();
+  return {
+    filePath: targetPath,
+    fileUrl,
+    filename: safeFileName,
+    size: content.byteLength
+  };
+}
+function validateOutboundAttachmentPath(candidatePath) {
+  if (!candidatePath || typeof candidatePath !== "string") {
+    throw new Error("\u9644\u4EF6\u8DEF\u5F84\u5FC5\u987B\u4E3A\u6709\u6548\u7684\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  if (candidatePath.includes("\0")) {
+    throw new Error("\u975E\u6CD5\u9644\u4EF6\u8DEF\u5F84\uFF1A\u68C0\u6D4B\u5230\u7A7A\u5B57\u8282\u6CE8\u5165");
+  }
+  const resolvedPath = path2.resolve(candidatePath);
+  const baseName = path2.basename(resolvedPath).toLowerCase();
+  if (baseName.startsWith(".env") || baseName === "id_rsa" || baseName === "id_ed25519" || baseName.endsWith(".pem") || baseName.endsWith(".key") || baseName === "shadow" || baseName === "passwd" || baseName === "sam" || baseName === "system") {
+    throw new Error(`\u5B89\u5168\u62E6\u622A\uFF1A\u4E25\u7981\u5916\u53D1\u7CFB\u7EDF\u5173\u952E\u654F\u611F\u51ED\u636E\u6587\u4EF6 "${baseName}"`);
+  }
+  const sandboxDir = getAttachmentSandboxDir();
+  const cwdDir = process.cwd();
+  const relSandbox = path2.relative(sandboxDir, resolvedPath);
+  const inSandbox = !relSandbox.startsWith("..") && !path2.isAbsolute(relSandbox);
+  const relCwd = path2.relative(cwdDir, resolvedPath);
+  const inCwd = !relCwd.startsWith("..") && !path2.isAbsolute(relCwd);
+  if (!inSandbox && !inCwd) {
+    throw new Error(
+      `\u5B89\u5168\u62E6\u622A\uFF1A\u5F85\u5916\u53D1\u9644\u4EF6\u8DEF\u5F84 "${candidatePath}" \u8D85\u51FA\u5141\u8BB8\u7684\u5B89\u5168\u76EE\u5F55\u8FB9\u754C\uFF08\u4EC5\u5141\u8BB8\u5F53\u524D\u5DE5\u4F5C\u533A\u6216\u6C99\u7BB1\u9644\u4EF6\u76EE\u5F55\uFF09`
+    );
+  }
+  return resolvedPath;
+}
+
+// src/services/mailbox-resolver.ts
+function resolveSpecialMailbox(logicalAlias, availableMailboxes = []) {
+  const normalized = (logicalAlias || "").trim().toLowerCase();
+  const items = availableMailboxes.map((m) => {
+    if (typeof m === "string") {
+      return { path: m, name: m };
+    }
+    return {
+      path: m.path || "",
+      name: m.name,
+      specialUse: m.specialUse
+    };
+  });
+  if (normalized === "inbox" || normalized === "\u6536\u4EF6\u7BB1") {
+    const found = items.find(
+      (m) => m.specialUse?.toLowerCase() === "\\inbox" || m.path?.toUpperCase() === "INBOX" || m.name?.toUpperCase() === "INBOX"
+    );
+    return found ? found.path : "INBOX";
+  }
+  if (normalized === "drafts" || normalized === "draft" || normalized === "\u8349\u7A3F\u7BB1" || normalized === "\u8349\u7A3F") {
+    const bySpecialUse = items.find(
+      (m) => m.specialUse?.toLowerCase() === "\\drafts"
+    );
+    if (bySpecialUse) {
+      return bySpecialUse.path;
+    }
+    const byName = items.find((m) => {
+      const p = m.path.toLowerCase();
+      const n = (m.name || "").toLowerCase();
+      return p === "drafts" || p === "\u8349\u7A3F\u7BB1" || p.endsWith("/drafts") || n === "drafts" || n === "\u8349\u7A3F\u7BB1";
+    });
+    if (byName) {
+      return byName.path;
+    }
+    return "Drafts";
+  }
+  if (normalized === "trash" || normalized === "bin" || normalized === "deleted" || normalized === "\u5DF2\u5220\u9664" || normalized === "\u56DE\u6536\u7AD9" || normalized === "\u5E9F\u4EF6\u7BB1") {
+    const bySpecialUse = items.find(
+      (m) => m.specialUse?.toLowerCase() === "\\trash"
+    );
+    if (bySpecialUse) {
+      return bySpecialUse.path;
+    }
+    const byName = items.find((m) => {
+      const p = m.path.toLowerCase();
+      const n = (m.name || "").toLowerCase();
+      return p === "trash" || p === "deleted messages" || p === "\u5DF2\u5220\u9664" || p === "\u56DE\u6536\u7AD9" || p.endsWith("/trash") || n === "trash" || n === "\u5DF2\u5220\u9664" || n === "\u56DE\u6536\u7AD9";
+    });
+    if (byName) {
+      return byName.path;
+    }
+    return "Trash";
+  }
+  if (normalized === "sent" || normalized === "\u5DF2\u53D1\u9001" || normalized === "sent messages") {
+    const bySpecialUse = items.find(
+      (m) => m.specialUse?.toLowerCase() === "\\sent"
+    );
+    if (bySpecialUse) {
+      return bySpecialUse.path;
+    }
+    const byName = items.find((m) => {
+      const p = m.path.toLowerCase();
+      const n = (m.name || "").toLowerCase();
+      return p === "sent" || p === "sent messages" || p === "\u5DF2\u53D1\u9001" || p.endsWith("/sent mail") || p.endsWith("/sent") || n === "sent" || n === "\u5DF2\u53D1\u9001";
+    });
+    if (byName) {
+      return byName.path;
+    }
+    return "Sent";
+  }
+  const exactMatch = items.find(
+    (m) => m.path.toLowerCase() === normalized || m.name && m.name.toLowerCase() === normalized
+  );
+  if (exactMatch) {
+    return exactMatch.path;
+  }
+  return logicalAlias;
+}
+async function buildRawMimeMessage(options, from) {
+  const transport = nodemailer.createTransport({
+    streamTransport: true,
+    buffer: true
+  });
+  let safeAttachments = options.attachments;
+  if (options.attachments && options.attachments.length > 0) {
+    safeAttachments = options.attachments.map((att) => {
+      if (att.path) {
+        const validated = validateOutboundAttachmentPath(att.path);
+        return { ...att, path: validated };
+      }
+      return att;
+    });
+  }
+  const mailOptions = {
+    from,
+    to: Array.isArray(options.to) ? options.to.join(", ") : options.to,
+    cc: options.cc ? Array.isArray(options.cc) ? options.cc.join(", ") : options.cc : void 0,
+    bcc: options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(", ") : options.bcc : void 0,
+    subject: options.subject,
+    text: options.text,
+    html: options.html,
+    attachments: safeAttachments,
+    inReplyTo: options.inReplyTo,
+    references: options.references
+  };
+  const info = await transport.sendMail(mailOptions);
+  return info.message;
+}
+function extractPreviewSnippet(raw, maxLength = 150) {
+  if (!raw) return "";
+  let text = typeof raw === "string" ? raw : raw.toString("utf-8");
+  text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'");
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (cleaned.length <= maxLength) {
+    return cleaned;
+  }
+  return cleaned.slice(0, maxLength) + "...";
+}
+function parseBodyFromRawOrParts(bodyParts, source) {
+  if (bodyParts) {
+    const textPart = bodyParts.get("TEXT") || bodyParts.get("1");
+    if (textPart) {
+      return textPart.toString("utf-8");
+    }
+  }
+  if (source) {
+    const raw = source.toString("utf-8");
+    const headerSplit = raw.indexOf("\r\n\r\n");
+    if (headerSplit !== -1) {
+      return raw.slice(headerSplit + 4);
+    }
+    const lfSplit = raw.indexOf("\n\n");
+    if (lfSplit !== -1) {
+      return raw.slice(lfSplit + 2);
+    }
+  }
+  return "";
+}
+
+// src/services/content-purifier.ts
+var MAX_EMAIL_BODY_BYTES = 30 * 1024;
+var TRUNCATION_NOTICE = "\n\n[\u63D0\u793A: \u90AE\u4EF6\u6B63\u6587\u5DF2\u8D85\u8FC7 30KB \u5B89\u5168\u9608\u503C\uFF0C\u5DF2\u6267\u884C\u622A\u65AD\u4FDD\u62A4]";
+function htmlToMarkdown(html) {
+  if (!html) return "";
+  let text = html;
+  text = text.replace(/<head[^>]*>[\s\S]*?<\/head>/gi, "");
+  text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<h1\b[^>]*>([\s\S]*?)<\/h1>/gi, "\n# $1\n");
+  text = text.replace(/<h2\b[^>]*>([\s\S]*?)<\/h2>/gi, "\n## $1\n");
+  text = text.replace(/<h3\b[^>]*>([\s\S]*?)<\/h3>/gi, "\n### $1\n");
+  text = text.replace(/<h4\b[^>]*>([\s\S]*?)<\/h4>/gi, "\n#### $1\n");
+  text = text.replace(/<h5\b[^>]*>([\s\S]*?)<\/h5>/gi, "\n##### $1\n");
+  text = text.replace(/<h6\b[^>]*>([\s\S]*?)<\/h6>/gi, "\n###### $1\n");
+  text = text.replace(/<(b|strong)\b[^>]*>([\s\S]*?)<\/\1>/gi, "**$2**");
+  text = text.replace(/<(i|em)\b[^>]*>([\s\S]*?)<\/\1>/gi, "*$2*");
+  text = text.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+  text = text.replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, "\n- $1");
+  text = text.replace(/<hr\b[^>]*\/?>/gi, "\n---\n");
+  text = text.replace(/<br\b[^>]*\/?>/gi, "\n");
+  text = text.replace(/<\/(p|div|tr)>/gi, "\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'");
+  const lines = text.split("\n").map((line) => line.trim());
+  const cleanLines = [];
+  let prevEmpty = false;
+  for (const line of lines) {
+    if (line.length === 0) {
+      if (!prevEmpty) {
+        cleanLines.push("");
+        prevEmpty = true;
+      }
+    } else {
+      cleanLines.push(line);
+      prevEmpty = false;
+    }
+  }
+  return cleanLines.join("\n").trim();
+}
+function purifyEmailBody(text, html) {
+  let rawContent = "";
+  if (html && html.trim().length > 0) {
+    rawContent = htmlToMarkdown(html);
+  } else if (text && text.trim().length > 0) {
+    rawContent = text.trim();
+  }
+  const byteLength = Buffer.byteLength(rawContent, "utf-8");
+  if (byteLength > MAX_EMAIL_BODY_BYTES) {
+    const buffer = Buffer.from(rawContent, "utf-8");
+    const sliced = buffer.subarray(0, MAX_EMAIL_BODY_BYTES);
+    const truncatedText = sliced.toString("utf-8");
+    return {
+      content: truncatedText + TRUNCATION_NOTICE,
+      truncated: true
+    };
+  }
+  return {
+    content: rawContent,
+    truncated: false
+  };
+}
+
+// src/services/imap.service.ts
+var ImapService = class {
+  constructor(imapConfig) {
+    this.imapConfig = imapConfig;
+  }
+  imapConfig;
+  /**
+   * 创建新的 IMAP 客户端连接
+   *
+   * @returns 初始化的 ImapFlow 客户端实例
+   * @throws Error 当未配置 IMAP 主机或账号时
+   */
+  createClient() {
+    const host = this.imapConfig?.host || config.MCP_IMAP_HOST;
+    const port = this.imapConfig?.port ?? config.MCP_IMAP_PORT;
+    const secure = this.imapConfig?.secure ?? config.MCP_IMAP_SECURE;
+    const user = this.imapConfig?.user || config.MCP_IMAP_USER;
+    const pass = this.imapConfig?.pass || config.MCP_IMAP_PASS;
+    if (!host || !user || !pass) {
+      throw new Error(
+        "IMAP \u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1A\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E MCP_IMAP_HOST\u3001MCP_IMAP_USER \u548C MCP_IMAP_PASS \u73AF\u5883\u53D8\u91CF"
+      );
+    }
+    return new ImapFlow({
+      host,
+      port,
+      secure,
+      auth: {
+        user,
+        pass
+      },
+      logger: false
+      // 禁用内部控制台输出，保护 MCP Stdio 通信通道
+    });
+  }
+  /**
+   * 获取远程邮箱目录列表
+   *
+   * @returns 邮箱目录路径列表
+   */
+  async listMailboxes() {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      return mailboxes.map((item) => item.path);
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 检索符合条件的邮件摘要列表
+   *
+   * @param filter 检索与过滤条件
+   * @returns 分页检索结果与条目摘要
+   */
+  async searchEmails(filter) {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const allMailboxes = await client.list();
+      const targetMailbox = resolveSpecialMailbox(filter.mailbox || "INBOX", allMailboxes);
+      const lock = await client.getMailboxLock(targetMailbox);
+      try {
+        const query = {};
+        if (filter.query) {
+          query.body = filter.query;
+        }
+        if (filter.unseenOnly) {
+          query.seen = false;
+        }
+        if (filter.flaggedOnly) {
+          query.flagged = true;
+        }
+        if (filter.from) {
+          query.from = filter.from;
+        }
+        if (filter.to) {
+          query.to = filter.to;
+        }
+        if (filter.subject) {
+          query.subject = filter.subject;
+        }
+        if (filter.since) {
+          query.since = new Date(filter.since);
+        }
+        if (filter.before) {
+          query.before = new Date(filter.before);
+        }
+        const searchCriteria = Object.keys(query).length > 0 ? query : { all: true };
+        const searchResult = await client.search(searchCriteria, { uid: true });
+        const uids = Array.isArray(searchResult) ? searchResult : [];
+        const total = uids.length;
+        const page = filter.page && filter.page > 0 ? filter.page : 1;
+        const limit = filter.limit && filter.limit > 0 ? filter.limit : 10;
+        if (total === 0) {
+          return {
+            items: [],
+            total: 0,
+            page,
+            limit,
+            hasMore: false
+          };
+        }
+        const sortedUids = [...uids].reverse();
+        let selectedUids = [];
+        let effectiveTotal = total;
+        let hasMore = false;
+        if (filter.hasAttachment === void 0) {
+          const startIndex = (page - 1) * limit;
+          selectedUids = sortedUids.slice(startIndex, startIndex + limit);
+          hasMore = startIndex + limit < total;
+        } else {
+          const maxScanLimit = Math.min(sortedUids.length, 100);
+          const scanUids = sortedUids.slice(0, maxScanLimit);
+          const matchedUids = [];
+          if (scanUids.length > 0) {
+            for await (const message of client.fetch(scanUids, {
+              uid: true,
+              bodyStructure: true
+            })) {
+              const hasAttachments = Boolean(
+                message.bodyStructure?.childNodes && message.bodyStructure.childNodes.length > 1
+              );
+              if (hasAttachments === filter.hasAttachment) {
+                matchedUids.push(message.uid);
+              }
+            }
+          }
+          matchedUids.sort((a, b) => b - a);
+          effectiveTotal = matchedUids.length;
+          const startIndex = (page - 1) * limit;
+          selectedUids = matchedUids.slice(startIndex, startIndex + limit);
+          hasMore = startIndex + limit < matchedUids.length;
+        }
+        const items = [];
+        if (selectedUids.length > 0) {
+          for await (const message of client.fetch(selectedUids, {
+            envelope: true,
+            flags: true,
+            internalDate: true,
+            uid: true,
+            bodyStructure: true,
+            bodyParts: ["TEXT", "1"],
+            source: { maxLength: 2048 }
+          })) {
+            const hasAttachments = Boolean(
+              message.bodyStructure?.childNodes && message.bodyStructure.childNodes.length > 1
+            );
+            const fromAddr = message.envelope?.from?.[0] ? `${message.envelope.from[0].name || ""} <${message.envelope.from[0].address || ""}>`.trim() : "\u672A\u77E5\u53D1\u4EF6\u4EBA";
+            const rawBody = parseBodyFromRawOrParts(message.bodyParts, message.source);
+            const preview = extractPreviewSnippet(rawBody, 150);
+            items.push({
+              uid: message.uid,
+              seq: message.seq,
+              from: fromAddr,
+              subject: message.envelope?.subject || "(\u65E0\u4E3B\u9898)",
+              date: message.envelope?.date?.toISOString() || (/* @__PURE__ */ new Date()).toISOString(),
+              unseen: !message.flags?.has("\\Seen"),
+              hasAttachments,
+              preview
+            });
+          }
+          items.sort((a, b) => b.uid - a.uid);
+        }
+        return {
+          items,
+          total: effectiveTotal,
+          page,
+          limit,
+          hasMore
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 根据 UID 获取邮件正文及附件明细（包含 Markdown 提纯与附件元数据清单）
+   *
+   * @param uid 邮件唯一标识符
+   * @param mailbox 所处邮箱文件夹或别名，默认 INBOX
+   * @returns 邮件详情数据
+   */
+  async getEmailDetail(uid, mailbox = "INBOX") {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const targetMailbox = resolveSpecialMailbox(mailbox, mailboxes);
+      const lock = await client.getMailboxLock(targetMailbox);
+      try {
+        const download = await client.download(String(uid), void 0, { uid: true });
+        if (!download || !download.content) {
+          throw new Error(`\u672A\u627E\u5230 UID \u4E3A ${uid} \u7684\u90AE\u4EF6\u5185\u5BB9`);
+        }
+        const parsed = await simpleParser(download.content);
+        const toList = [];
+        if (parsed.to) {
+          if (Array.isArray(parsed.to)) {
+            parsed.to.forEach((addr) => toList.push(addr.text));
+          } else {
+            toList.push(parsed.to.text);
+          }
+        }
+        const ccList = [];
+        if (parsed.cc) {
+          if (Array.isArray(parsed.cc)) {
+            parsed.cc.forEach((addr) => ccList.push(addr.text));
+          } else {
+            ccList.push(parsed.cc.text);
+          }
+        }
+        const attachments = (parsed.attachments || []).map((att, idx) => ({
+          id: String(idx),
+          filename: att.filename || `attachment-${idx}`,
+          contentType: att.contentType || "application/octet-stream",
+          size: att.size || (att.content ? att.content.length : 0)
+        }));
+        const fromAddress = parsed.from?.value?.[0]?.address || void 0;
+        let references;
+        if (parsed.references) {
+          references = Array.isArray(parsed.references) ? parsed.references : [parsed.references];
+        }
+        const purified = purifyEmailBody(
+          parsed.text,
+          typeof parsed.html === "string" ? parsed.html : void 0
+        );
+        return {
+          uid,
+          from: parsed.from?.text || "\u672A\u77E5\u53D1\u4EF6\u4EBA",
+          fromAddress,
+          to: toList,
+          cc: ccList.length > 0 ? ccList : void 0,
+          subject: parsed.subject || "(\u65E0\u4E3B\u9898)",
+          date: parsed.date ? parsed.date.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+          text: parsed.text,
+          html: typeof parsed.html === "string" ? parsed.html : void 0,
+          bodyMarkdown: purified.content,
+          truncated: purified.truncated,
+          messageId: parsed.messageId,
+          inReplyTo: parsed.inReplyTo,
+          references,
+          attachments
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 从指定邮件中提取附件并下载保存至受管本地沙箱
+   *
+   * @param uid 邮件唯一标识符
+   * @param attachmentIdentifier 附件唯一标识（ID 序号或文件名）
+   * @param mailbox 所在邮箱文件夹，默认 INBOX
+   * @returns 下载落盘结果
+   * @throws Error 当未找到邮件或目标附件时
+   */
+  async downloadAttachment(uid, attachmentIdentifier, mailbox = "INBOX") {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const targetMailbox = resolveSpecialMailbox(mailbox, mailboxes);
+      const lock = await client.getMailboxLock(targetMailbox);
+      try {
+        const download = await client.download(String(uid), void 0, { uid: true });
+        if (!download || !download.content) {
+          throw new Error(`\u672A\u627E\u5230 UID \u4E3A ${uid} \u7684\u90AE\u4EF6\u5185\u5BB9`);
+        }
+        const parsed = await simpleParser(download.content);
+        const attachments = parsed.attachments || [];
+        const targetIndex = attachments.findIndex(
+          (att, idx) => String(idx) === String(attachmentIdentifier) || att.filename === attachmentIdentifier
+        );
+        if (targetIndex === -1) {
+          throw new Error(
+            `\u672A\u5728\u90AE\u4EF6 (UID: ${uid}) \u4E2D\u627E\u5230\u6807\u8BC6\u4E3A "${attachmentIdentifier}" \u7684\u9644\u4EF6`
+          );
+        }
+        const targetAttachment = attachments[targetIndex];
+        if (!targetAttachment.content) {
+          throw new Error(
+            `\u9644\u4EF6 "${targetAttachment.filename || attachmentIdentifier}" \u5185\u5BB9\u4E3A\u7A7A\u6216\u65E0\u6CD5\u63D0\u53D6`
+          );
+        }
+        const rawFileName = targetAttachment.filename || `attachment-${targetIndex}`;
+        const saved = await saveAttachmentToSandbox(rawFileName, targetAttachment.content, void 0, uid);
+        return {
+          attachmentId: String(targetIndex),
+          filename: saved.filename,
+          contentType: targetAttachment.contentType || "application/octet-stream",
+          size: saved.size,
+          filePath: saved.filePath,
+          fileUrl: saved.fileUrl
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 验证 IMAP 服务的网络握手与身份认证
+   *
+   * @returns 是否连接成功
+   */
+  async verifyConnection() {
+    const client = this.createClient();
+    try {
+      await client.connect();
+      return true;
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 将邮件载荷组装为 RFC 822 MIME 数据并存入草稿箱
+   *
+   * @param options 邮件选项载荷
+   * @param from 发件人地址
+   * @returns 存储结果，包含物理草稿箱路径
+   */
+  async createDraft(options, from) {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const draftsPath = resolveSpecialMailbox("drafts", mailboxes);
+      const rawMime = await buildRawMimeMessage(options, from);
+      await client.append(draftsPath, rawMime, ["\\Draft", "\\Seen"]);
+      return {
+        success: true,
+        mailbox: draftsPath
+      };
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 极速获取邮箱文件夹状态与未读统计看板
+   *
+   * @param mailboxAlias 可选指定文件夹别名或物理路径，缺省时查询全部可用文件夹
+   * @returns 邮箱状态看板概览报告
+   */
+  async getMailboxStatus(mailboxAlias) {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const allMailboxes = await client.list();
+      if (mailboxAlias && mailboxAlias.toUpperCase() !== "ALL") {
+        const resolvedPath = resolveSpecialMailbox(mailboxAlias, allMailboxes);
+        const status = await client.status(resolvedPath, {
+          messages: true,
+          unseen: true,
+          recent: true
+        });
+        const item = {
+          mailbox: resolvedPath,
+          total: status.messages || 0,
+          unseen: status.unseen || 0,
+          recent: status.recent || 0
+        };
+        return {
+          mailboxes: [item],
+          totalUnseen: item.unseen,
+          totalMessages: item.total
+        };
+      }
+      const statusPromises = allMailboxes.map(async (box) => {
+        try {
+          const status = await client.status(box.path, {
+            messages: true,
+            unseen: true,
+            recent: true
+          });
+          return {
+            mailbox: box.path,
+            total: status.messages || 0,
+            unseen: status.unseen || 0,
+            recent: status.recent || 0
+          };
+        } catch {
+          return {
+            mailbox: box.path,
+            total: 0,
+            unseen: 0,
+            recent: 0
+          };
+        }
+      });
+      const items = await Promise.all(statusPromises);
+      let totalUnseen = 0;
+      let totalMessages = 0;
+      for (const item of items) {
+        totalUnseen += item.unseen;
+        totalMessages += item.total;
+      }
+      return {
+        mailboxes: items,
+        totalUnseen,
+        totalMessages
+      };
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 将邮件 UID 或 UID 列表格式化为 IMAP SequenceSet 字符串并执行有效性校验
+   *
+   * @param uids 单个 UID 或 UID 数组
+   * @returns 规整后的 IMAP 查询范围字符串与计数
+   * @throws Error 当未提供任何有效 UID 时
+   */
+  formatUidRange(uids) {
+    const list = Array.isArray(uids) ? uids : [uids];
+    const valid = list.filter((u) => typeof u === "number" && !isNaN(u) && u > 0);
+    if (valid.length === 0) {
+      throw new Error("\u8BF7\u63D0\u4F9B\u81F3\u5C11\u4E00\u4E2A\u6709\u6548\u7684\u90AE\u4EF6 UID \u6807\u8BC6\u7B26");
+    }
+    const sorted = Array.from(new Set(valid)).sort((a, b) => a - b);
+    return {
+      range: sorted.join(","),
+      count: sorted.length
+    };
+  }
+  /**
+   * 修改邮件的已读/未读状态标记 (\Seen)
+   *
+   * @param uids 单个邮件 UID 或 UID 列表
+   * @param read 是否标记为已读（true 为已读，false 为未读，默认 true）
+   * @param mailbox 所在邮箱文件夹别名或物理路径，默认 INBOX
+   * @returns 状态流转操作结果
+   */
+  async markEmailRead(uids, read = true, mailbox = "INBOX") {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const resolvedMailbox = resolveSpecialMailbox(mailbox, mailboxes);
+      const lock = await client.getMailboxLock(resolvedMailbox);
+      try {
+        const { range, count } = this.formatUidRange(uids);
+        if (read) {
+          await client.messageFlagsAdd(range, ["\\Seen"], { uid: true });
+        } else {
+          await client.messageFlagsRemove(range, ["\\Seen"], { uid: true });
+        }
+        return {
+          success: true,
+          count,
+          read
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 修改邮件的星标/置顶标记 (\Flagged)
+   *
+   * @param uids 单个邮件 UID 或 UID 列表
+   * @param flagged 是否设置星标（true 为星标，false 为取消星标，默认 true）
+   * @param mailbox 所在邮箱文件夹别名或物理路径，默认 INBOX
+   * @returns 星标设置操作结果
+   */
+  async flagEmail(uids, flagged = true, mailbox = "INBOX") {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const resolvedMailbox = resolveSpecialMailbox(mailbox, mailboxes);
+      const lock = await client.getMailboxLock(resolvedMailbox);
+      try {
+        const { range, count } = this.formatUidRange(uids);
+        if (flagged) {
+          await client.messageFlagsAdd(range, ["\\Flagged"], { uid: true });
+        } else {
+          await client.messageFlagsRemove(range, ["\\Flagged"], { uid: true });
+        }
+        return {
+          success: true,
+          count,
+          flagged
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+  /**
+   * 将邮件跨文件夹移动或转移至回收站进行安全软删除（彻底杜绝物理硬删除 EXPUNGE）
+   *
+   * @param uids 单个邮件 UID 或 UID 列表
+   * @param targetMailbox 目标邮箱文件夹别名或物理路径（如 trash, archive, INBOX）
+   * @param sourceMailbox 源邮箱文件夹别名或物理路径，默认 INBOX
+   * @returns 移动结果，包含实际物理源路径与目标路径
+   */
+  async moveEmail(uids, targetMailbox, sourceMailbox = "INBOX") {
+    const client = this.createClient();
+    await client.connect();
+    try {
+      const mailboxes = await client.list();
+      const resolvedSource = resolveSpecialMailbox(sourceMailbox, mailboxes);
+      const resolvedTarget = resolveSpecialMailbox(targetMailbox, mailboxes);
+      const lock = await client.getMailboxLock(resolvedSource);
+      try {
+        const { range, count } = this.formatUidRange(uids);
+        await client.messageMove(range, resolvedTarget, { uid: true });
+        return {
+          success: true,
+          count,
+          sourceMailbox: resolvedSource,
+          targetMailbox: resolvedTarget
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout().catch(() => {
+      });
+    }
+  }
+};
+var imapService = new ImapService();
+
+// src/services/smtp.service.ts
+import nodemailer2 from "nodemailer";
+var SmtpService = class {
+  constructor(smtpConfig) {
+    this.smtpConfig = smtpConfig;
+  }
+  smtpConfig;
+  transporter = null;
+  /**
+   * 初始化并获取 Nodemailer 传输器单例
+   *
+   * @returns 初始化的 Transporter 实例
+   * @throws Error 当未配置 SMTP 主机或账号时
+   */
+  getTransporter() {
+    if (this.transporter) {
+      return this.transporter;
+    }
+    const host = this.smtpConfig?.host || config.MCP_SMTP_HOST;
+    const port = this.smtpConfig?.port ?? config.MCP_SMTP_PORT;
+    const secure = this.smtpConfig?.secure ?? config.MCP_SMTP_SECURE;
+    const user = this.smtpConfig?.user || config.MCP_SMTP_USER;
+    const pass = this.smtpConfig?.pass || config.MCP_SMTP_PASS;
+    if (!host || !user || !pass) {
+      throw new Error(
+        "SMTP \u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1A\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E MCP_SMTP_HOST\u3001MCP_SMTP_USER \u548C MCP_SMTP_PASS \u73AF\u5883\u53D8\u91CF"
+      );
+    }
+    this.transporter = nodemailer2.createTransport({
+      host,
+      port,
+      secure,
+      auth: {
+        user,
+        pass
+      }
+    });
+    return this.transporter;
+  }
+  /**
+   * 发送电子邮件
+   *
+   * @param options 发送邮件配置与内容选项
+   * @returns 发送结果明细，包含 messageId
+   * @throws Error 当发送失败时
+   */
+  async sendEmail(options) {
+    const client = this.getTransporter();
+    let safeAttachments = options.attachments;
+    if (options.attachments && options.attachments.length > 0) {
+      safeAttachments = options.attachments.map((att) => {
+        if (att.path) {
+          const validated = validateOutboundAttachmentPath(att.path);
+          return { ...att, path: validated };
+        }
+        return att;
+      });
+    }
+    const from = options.from || this.smtpConfig?.from || this.smtpConfig?.user || config.MCP_SMTP_FROM || config.MCP_SMTP_USER;
+    const mailOptions = {
+      from,
+      to: Array.isArray(options.to) ? options.to.join(", ") : options.to,
+      cc: options.cc ? Array.isArray(options.cc) ? options.cc.join(", ") : options.cc : void 0,
+      bcc: options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(", ") : options.bcc : void 0,
+      subject: options.subject,
+      text: options.text,
+      html: options.html,
+      attachments: safeAttachments,
+      inReplyTo: options.inReplyTo,
+      references: options.references
+    };
+    const info = await client.sendMail(mailOptions);
+    return {
+      messageId: info.messageId,
+      accepted: Array.isArray(info.accepted) ? info.accepted : []
+    };
+  }
+  /**
+   * 验证 SMTP 服务的网络与认证联通性
+   *
+   * @returns 是否连接成功
+   */
+  async verifyConnection() {
+    const client = this.getTransporter();
+    await client.verify();
+    return true;
+  }
+};
+var smtpService = new SmtpService();
+
+// src/services/account-manager.ts
+var AccountManager = class {
+  accounts = /* @__PURE__ */ new Map();
+  defaultAccountId;
+  smtpPool = /* @__PURE__ */ new Map();
+  imapPool = /* @__PURE__ */ new Map();
+  /**
+   * 构造账户管理器实例
+   *
+   * @param accountList 预加载的账户画像列表，缺省为 config.accounts
+   * @param defaultId 默认账户标识，缺省为 config.defaultAccountId
+   */
+  constructor(accountList = config.accounts, defaultId = config.defaultAccountId) {
+    accountList.forEach((acc) => {
+      this.accounts.set(acc.id, acc);
+    });
+    this.defaultAccountId = defaultId;
+  }
+  /**
+   * 列出所有已配置的账户脱敏元数据（隐藏密码与授权码）
+   *
+   * @returns 脱敏账户画像列表
+   */
+  listAccounts() {
+    const result = [];
+    for (const [id, acc] of this.accounts.entries()) {
+      result.push({
+        id,
+        name: acc.name,
+        email: acc.email || acc.smtp?.user || acc.imap?.user,
+        isDefault: id === this.defaultAccountId,
+        smtp: acc.smtp ? {
+          host: acc.smtp.host,
+          port: acc.smtp.port,
+          secure: acc.smtp.secure,
+          user: acc.smtp.user,
+          from: acc.smtp.from
+        } : void 0,
+        imap: acc.imap ? {
+          host: acc.imap.host,
+          port: acc.imap.port,
+          secure: acc.imap.secure,
+          user: acc.imap.user
+        } : void 0
+      });
+    }
+    return result;
+  }
+  /**
+   * 获取指定的账户画像，缺省时自动回退至默认账户
+   *
+   * @param accountId 可选的账户标识
+   * @returns 目标账户完整画像
+   * @throws Error 当未找到指定或默认账户配置时
+   */
+  getAccount(accountId) {
+    const targetId = accountId || this.defaultAccountId;
+    const account = this.accounts.get(targetId);
+    if (!account) {
+      if (accountId) {
+        throw new Error(
+          `\u672A\u627E\u5230\u6307\u5B9A\u6807\u8BC6\u4E3A "${accountId}" \u7684\u90AE\u7BB1\u8D26\u6237\u914D\u7F6E\uFF0C\u8BF7\u901A\u8FC7 list_accounts \u67E5\u770B\u53EF\u7528\u753B\u50CF`
+        );
+      }
+      throw new Error(
+        `\u672A\u627E\u5230\u9ED8\u8BA4\u90AE\u7BB1\u8D26\u6237\u914D\u7F6E (defaultId: "${this.defaultAccountId}")\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E`
+      );
+    }
+    return account;
+  }
+  /**
+   * 根据账户标识路由并获取缓存的 SMTP 服务实例
+   *
+   * @param accountId 可选账户标识
+   * @returns SMTP 服务实例
+   */
+  getSmtpService(accountId) {
+    const account = this.getAccount(accountId);
+    if (!account.smtp) {
+      throw new Error(`\u8D26\u6237 "${account.id}" \u672A\u914D\u7F6E SMTP \u5916\u53D1\u670D\u52A1\u53C2\u6570`);
+    }
+    let service = this.smtpPool.get(account.id);
+    if (!service) {
+      service = new SmtpService(account.smtp);
+      this.smtpPool.set(account.id, service);
+    }
+    return service;
+  }
+  /**
+   * 根据账户标识路由并获取缓存的 IMAP 服务实例
+   *
+   * @param accountId 可选账户标识
+   * @returns IMAP 服务实例
+   */
+  getImapService(accountId) {
+    const account = this.getAccount(accountId);
+    if (!account.imap) {
+      throw new Error(`\u8D26\u6237 "${account.id}" \u672A\u914D\u7F6E IMAP \u67E5\u6536\u670D\u52A1\u53C2\u6570`);
+    }
+    let service = this.imapPool.get(account.id);
+    if (!service) {
+      service = new ImapService(account.imap);
+      this.imapPool.set(account.id, service);
+    }
+    return service;
+  }
+  /**
+   * 对指定或默认账户执行网络连通性与认证体检
+   *
+   * @param accountId 可选账户标识
+   * @returns 综合体检诊断报告
+   */
+  async verifyConnection(accountId) {
+    const account = this.getAccount(accountId);
+    const smtpResult = {
+      configured: Boolean(account.smtp),
+      success: false,
+      host: account.smtp?.host,
+      port: account.smtp?.port
+    };
+    if (account.smtp) {
+      try {
+        const smtpClient = this.getSmtpService(account.id);
+        await smtpClient.verifyConnection();
+        smtpResult.success = true;
+      } catch (err) {
+        smtpResult.error = err instanceof Error ? err.message : String(err);
+      }
+    }
+    const imapResult = {
+      configured: Boolean(account.imap),
+      success: false,
+      host: account.imap?.host,
+      port: account.imap?.port
+    };
+    if (account.imap) {
+      try {
+        const imapClient = this.getImapService(account.id);
+        await imapClient.verifyConnection();
+        imapResult.success = true;
+      } catch (err) {
+        imapResult.error = err instanceof Error ? err.message : String(err);
+      }
+    }
+    const overallSuccess = (!smtpResult.configured || smtpResult.success) && (!imapResult.configured || imapResult.success) && (smtpResult.configured || imapResult.configured);
+    return {
+      account: account.id,
+      smtp: smtpResult,
+      imap: imapResult,
+      overallSuccess
+    };
+  }
+};
+var accountManager = new AccountManager();
+
+// src/services/reply.service.ts
+function extractEmailAddress(input) {
+  const match = input.match(/<([^>]+)>/);
+  if (match && match[1]) {
+    return match[1].trim().toLowerCase();
+  }
+  return input.trim().toLowerCase();
+}
+function formatReplySubject(subject) {
+  const cleanSubject = (subject || "").trim();
+  if (/^re:\s*/i.test(cleanSubject)) {
+    return cleanSubject;
+  }
+  return `Re: ${cleanSubject || "(\u65E0\u4E3B\u9898)"}`;
+}
+async function replyEmail(options, account, imapService2, smtpService2) {
+  const mailbox = options.mailbox || "INBOX";
+  const original = await imapService2.getEmailDetail(options.originalUid, mailbox);
+  if (!original) {
+    throw new Error(`\u672A\u627E\u5230 UID \u4E3A ${options.originalUid} \u7684\u539F\u59CB\u90AE\u4EF6`);
+  }
+  const to = original.fromAddress || extractEmailAddress(original.from);
+  let cc;
+  if (options.replyAll) {
+    const selfAddresses = /* @__PURE__ */ new Set();
+    if (account.email) {
+      selfAddresses.add(account.email.toLowerCase());
+    }
+    if (account.smtp?.user) {
+      selfAddresses.add(account.smtp.user.toLowerCase());
+    }
+    if (account.imap?.user) {
+      selfAddresses.add(account.imap.user.toLowerCase());
+    }
+    if (account.smtp?.from) {
+      selfAddresses.add(extractEmailAddress(account.smtp.from));
+    }
+    const allOriginalRecipients = [...original.to || [], ...original.cc || []];
+    const ccSet = /* @__PURE__ */ new Set();
+    for (const raw of allOriginalRecipients) {
+      const email = extractEmailAddress(raw);
+      if (email && email !== to && !selfAddresses.has(email)) {
+        ccSet.add(email);
+      }
+    }
+    if (ccSet.size > 0) {
+      cc = Array.from(ccSet);
+    }
+  }
+  const inReplyTo = original.messageId;
+  const references = original.references ? [...original.references] : [];
+  if (original.messageId && !references.includes(original.messageId)) {
+    references.push(original.messageId);
+  }
+  const subject = formatReplySubject(original.subject);
+  const sendResult = await smtpService2.sendEmail({
+    to,
+    cc,
+    subject,
+    text: options.text,
+    html: options.html,
+    attachments: options.attachments,
+    inReplyTo,
+    references: references.length > 0 ? references : void 0
+  });
+  return {
+    messageId: sendResult.messageId,
+    accepted: sendResult.accepted,
+    inReplyTo,
+    references: references.length > 0 ? references : void 0,
+    to,
+    cc,
+    subject
+  };
+}
+
+// src/tools/index.ts
+function registerEmailTools(server) {
+  server.tool(
+    "list_accounts",
+    "\u5217\u51FA\u6240\u6709\u5DF2\u914D\u7F6E\u7684\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u5217\u8868\uFF08\u51ED\u636E\u5B89\u5168\u8131\u654F\uFF0C\u9690\u85CF\u5BC6\u7801\uFF09\uFF0C\u5305\u542B\u8D26\u6237\u6807\u8BC6\u3001\u90AE\u7BB1\u5730\u5740\u3001\u670D\u52A1\u914D\u7F6E\u4E0E\u9ED8\u8BA4\u8D26\u6237\u6807\u8BB0",
+    {},
+    async () => {
+      try {
+        const accounts = accountManager.listAccounts();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(accounts, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u83B7\u53D6\u8D26\u6237\u5217\u8868\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "verify_connection",
+    "\u9A8C\u8BC1\u6307\u5B9A\u6216\u9ED8\u8BA4\u90AE\u7BB1\u8D26\u6237\u7684\u7F51\u7EDC\u8FDE\u901A\u6027\u4E0E\u8BA4\u8BC1\u51ED\u636E\uFF08\u5305\u62EC SMTP \u5916\u53D1\u548C IMAP \u67E5\u6536\u901A\u9053\uFF09\uFF0C\u8FD4\u56DE\u7F51\u7EDC\u63E1\u624B\u4E0E\u8EAB\u4EFD\u8BA4\u8BC1\u4F53\u68C0\u62A5\u544A",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F53\u68C0\u9ED8\u8BA4\u8D26\u6237")
+    },
+    async (args) => {
+      try {
+        const report = await accountManager.verifyConnection(args.account);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(report, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u9A8C\u8BC1\u8D26\u6237\u8FDE\u63A5\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "send_email",
+    "\u53D1\u9001\u7535\u5B50\u90AE\u4EF6\uFF0C\u652F\u6301\u7EAF\u6587\u672C\u3001HTML \u6B63\u6587\u4EE5\u53CA\u6587\u4EF6\u9644\u4EF6",
+    {
+      account: z2.string().optional().describe("\u53D1\u4FE1\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      to: z2.union([z2.string(), z2.array(z2.string())]).describe("\u6536\u4EF6\u4EBA\u90AE\u7BB1\u5730\u5740\uFF0C\u5355\u4E2A\u6216\u6570\u7EC4"),
+      subject: z2.string().describe("\u90AE\u4EF6\u4E3B\u9898"),
+      text: z2.string().optional().describe("\u7EAF\u6587\u672C\u6B63\u6587\u5185\u5BB9"),
+      html: z2.string().optional().describe("HTML \u683C\u5F0F\u6B63\u6587\u5185\u5BB9"),
+      cc: z2.union([z2.string(), z2.array(z2.string())]).optional().describe("\u6284\u9001\u90AE\u7BB1\u5730\u5740"),
+      bcc: z2.union([z2.string(), z2.array(z2.string())]).optional().describe("\u5BC6\u9001\u90AE\u7BB1\u5730\u5740"),
+      attachments: z2.array(
+        z2.object({
+          filename: z2.string().describe("\u9644\u4EF6\u6587\u4EF6\u540D"),
+          path: z2.string().optional().describe("\u672C\u5730\u6587\u4EF6\u7EDD\u5BF9\u8DEF\u5F84"),
+          content: z2.string().optional().describe("\u9644\u4EF6\u6587\u672C\u5185\u5BB9\u6216 Base64 \u7F16\u7801\u5B57\u7B26\u4E32"),
+          contentType: z2.string().optional().describe("MIME \u7C7B\u578B")
+        })
+      ).optional().describe("\u9644\u4EF6\u5217\u8868")
+    },
+    async (args) => {
+      try {
+        const smtpService2 = accountManager.getSmtpService(args.account);
+        const result = await smtpService2.sendEmail({
+          to: args.to,
+          subject: args.subject,
+          text: args.text,
+          html: args.html,
+          cc: args.cc,
+          bcc: args.bcc,
+          attachments: args.attachments
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u90AE\u4EF6\u53D1\u9001\u6210\u529F\uFF01MessageID: ${result.messageId}\uFF0C\u5DF2\u6295\u9012\u81F3: ${result.accepted.join(", ")}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u53D1\u9001\u90AE\u4EF6\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "reply_email",
+    "\u56DE\u590D\u6307\u5B9A\u90AE\u4EF6\uFF0C\u81EA\u52A8\u4FDD\u6301\u539F\u751F\u4F1A\u8BDD\u6298\u53E0\u6811\uFF08\u81EA\u52A8\u6CE8\u5165 In-Reply-To\u3001References \u90AE\u4EF6\u5934\uFF0C\u6DFB\u52A0 Re: \u4E3B\u9898\u524D\u7F00\uFF0C\u652F\u6301\u4E00\u952E replyAll \u4FDD\u7559\u539F\u6284\u9001\u4EBA\uFF09",
+    {
+      account: z2.string().optional().describe("\u53D1\u9001\u56DE\u590D\u7684\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      originalUid: z2.number().describe("\u88AB\u56DE\u590D\u539F\u90AE\u4EF6\u7684\u552F\u4E00 UID \u6807\u8BC6\u7B26"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u539F\u90AE\u4EF6\u6240\u5728\u90AE\u7BB1\u6587\u4EF6\u5939\u540D\u79F0\uFF0C\u9ED8\u8BA4\u4E3A INBOX"),
+      text: z2.string().optional().describe("\u56DE\u590D\u7684\u7EAF\u6587\u672C\u6B63\u6587\u5185\u5BB9"),
+      html: z2.string().optional().describe("\u56DE\u590D\u7684 HTML \u683C\u5F0F\u6B63\u6587\u5185\u5BB9"),
+      replyAll: z2.boolean().optional().default(false).describe("\u662F\u5426\u5168\u5458\u56DE\u590D\uFF08\u6284\u9001\u9664\u81EA\u8EAB\u5916\u7684\u539F\u90AE\u4EF6\u6536\u4EF6\u4EBA\u4E0E\u6284\u9001\u4EBA\uFF09"),
+      attachments: z2.array(
+        z2.object({
+          filename: z2.string().describe("\u9644\u4EF6\u6587\u4EF6\u540D"),
+          path: z2.string().optional().describe("\u672C\u5730\u6587\u4EF6\u7EDD\u5BF9\u8DEF\u5F84"),
+          content: z2.string().optional().describe("\u9644\u4EF6\u6587\u672C\u5185\u5BB9\u6216 Base64 \u7F16\u7801\u5B57\u7B26\u4E32"),
+          contentType: z2.string().optional().describe("MIME \u7C7B\u578B")
+        })
+      ).optional().describe("\u9644\u4EF6\u5217\u8868")
+    },
+    async (args) => {
+      try {
+        const account = accountManager.getAccount(args.account);
+        const imapService2 = accountManager.getImapService(args.account);
+        const smtpService2 = accountManager.getSmtpService(args.account);
+        const result = await replyEmail(
+          {
+            originalUid: args.originalUid,
+            mailbox: args.mailbox,
+            text: args.text,
+            html: args.html,
+            replyAll: args.replyAll,
+            attachments: args.attachments
+          },
+          account,
+          imapService2,
+          smtpService2
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u90AE\u4EF6\u56DE\u590D\u6210\u529F\uFF01MessageID: ${result.messageId}\uFF0C\u5DF2\u56DE\u590D\u81F3: ${result.to}${result.cc ? ` (\u6284\u9001: ${result.cc.join(", ")})` : ""}\uFF0C\u4E3B\u9898: ${result.subject}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u56DE\u590D\u90AE\u4EF6\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "create_draft",
+    "\u5C06\u62DF\u5B9A\u90AE\u4EF6\u5B58\u5165\u90AE\u7BB1\u8349\u7A3F\u7BB1\uFF08Drafts\uFF09\uFF0C\u4F9B\u4EBA\u5DE5\u5728\u90AE\u7BB1\u5BA2\u6237\u7AEF\u4E2D\u6700\u7EC8\u5BA1\u9605\u786E\u8BA4\u540E\u53D1\u51FA",
+    {
+      account: z2.string().optional().describe("\u8349\u7A3F\u6240\u5C5E\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      to: z2.union([z2.string(), z2.array(z2.string())]).optional().describe("\u6536\u4EF6\u4EBA\u90AE\u7BB1\u5730\u5740\uFF0C\u5355\u4E2A\u6216\u6570\u7EC4"),
+      subject: z2.string().optional().default("(\u65E0\u4E3B\u9898)").describe("\u90AE\u4EF6\u4E3B\u9898"),
+      text: z2.string().optional().describe("\u7EAF\u6587\u672C\u6B63\u6587\u5185\u5BB9"),
+      html: z2.string().optional().describe("HTML \u683C\u5F0F\u6B63\u6587\u5185\u5BB9"),
+      cc: z2.union([z2.string(), z2.array(z2.string())]).optional().describe("\u6284\u9001\u90AE\u7BB1\u5730\u5740"),
+      bcc: z2.union([z2.string(), z2.array(z2.string())]).optional().describe("\u5BC6\u9001\u90AE\u7BB1\u5730\u5740"),
+      attachments: z2.array(
+        z2.object({
+          filename: z2.string().describe("\u9644\u4EF6\u6587\u4EF6\u540D"),
+          path: z2.string().optional().describe("\u672C\u5730\u6587\u4EF6\u7EDD\u5BF9\u8DEF\u5F84"),
+          content: z2.string().optional().describe("\u9644\u4EF6\u6587\u672C\u5185\u5BB9\u6216 Base64 \u7F16\u7801\u5B57\u7B26\u4E32"),
+          contentType: z2.string().optional().describe("MIME \u7C7B\u578B")
+        })
+      ).optional().describe("\u9644\u4EF6\u5217\u8868")
+    },
+    async (args) => {
+      try {
+        const account = accountManager.getAccount(args.account);
+        const imapService2 = accountManager.getImapService(args.account);
+        const from = account.smtp?.from || account.smtp?.user || account.email || "user@example.com";
+        const result = await imapService2.createDraft(
+          {
+            to: args.to || "",
+            subject: args.subject || "(\u65E0\u4E3B\u9898)",
+            text: args.text,
+            html: args.html,
+            cc: args.cc,
+            bcc: args.bcc,
+            attachments: args.attachments
+          },
+          from
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u8349\u7A3F\u5DF2\u6210\u529F\u4FDD\u5B58\u81F3 [${result.mailbox}]\uFF01\u4E3B\u9898: ${args.subject || "(\u65E0\u4E3B\u9898)"}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u4FDD\u5B58\u8349\u7A3F\u7BB1\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_mailbox_status",
+    "\u6781\u901F\u83B7\u53D6\u6307\u5B9A\u6216\u5168\u90E8\u90AE\u7BB1\u6587\u4EF6\u5939\u7684\u72B6\u6001\u770B\u677F\uFF08\u5305\u542B\u603B\u90AE\u4EF6\u6570\u3001\u672A\u8BFB\u90AE\u4EF6\u6570\u4E0E\u6700\u8FD1\u90AE\u4EF6\u6570\uFF09\uFF0C\u6BEB\u79D2\u7EA7\u54CD\u5E94",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      mailbox: z2.string().optional().describe(
+        "\u76EE\u6807\u90AE\u7BB1\u6587\u4EF6\u5939\u522B\u540D\u6216\u7269\u7406\u8DEF\u5F84\uFF08\u5982 inbox, drafts, trash \u6216 INBOX\uFF09\uFF0C\u7F3A\u7701\u65F6\u7EDF\u8BA1\u5168\u90E8\u53EF\u7528\u6587\u4EF6\u5939"
+      )
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const report = await imapService2.getMailboxStatus(args.mailbox);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(report, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u83B7\u53D6\u90AE\u7BB1\u72B6\u6001\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "search_emails",
+    "\u5728\u90AE\u7BB1\u4E2D\u6309\u591A\u7EF4\u6761\u4EF6\u68C0\u7D22\u90AE\u4EF6\uFF0C\u8FD4\u56DE\u5305\u542B 150 \u5B57\u7B26 Preview \u7EAF\u6587\u672C\u6458\u8981\u7684\u5206\u9875\u5217\u8868",
+    {
+      account: z2.string().optional().describe("\u6536\u4FE1\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u90AE\u7BB1\u6587\u4EF6\u5939\u540D\u79F0\u6216\u522B\u540D\uFF08\u5982 inbox, drafts, trash\uFF09\uFF0C\u9ED8\u8BA4\u4E3A INBOX"),
+      query: z2.string().optional().describe("\u5168\u6587\u68C0\u7D22\u5173\u952E\u5B57\uFF08\u5339\u914D\u53D1\u4EF6\u4EBA\u3001\u4E3B\u9898\u6216\u6B63\u6587\uFF09"),
+      from: z2.string().optional().describe("\u6309\u53D1\u4EF6\u4EBA\u5730\u5740\u6216\u5173\u952E\u5B57\u7B5B\u9009"),
+      to: z2.string().optional().describe("\u6309\u6536\u4EF6\u4EBA\u5730\u5740\u6216\u5173\u952E\u5B57\u7B5B\u9009"),
+      subject: z2.string().optional().describe("\u6309\u90AE\u4EF6\u4E3B\u9898\u5173\u952E\u5B57\u7B5B\u9009"),
+      unseenOnly: z2.boolean().optional().default(false).describe("\u662F\u5426\u4EC5\u67E5\u8BE2\u672A\u8BFB\u90AE\u4EF6"),
+      flaggedOnly: z2.boolean().optional().default(false).describe("\u662F\u5426\u4EC5\u67E5\u8BE2\u661F\u6807/\u7F6E\u9876\u90AE\u4EF6"),
+      hasAttachment: z2.boolean().optional().describe("\u662F\u5426\u5FC5\u987B\u5305\u542B\u9644\u4EF6"),
+      since: z2.string().optional().describe("\u8D77\u59CB\u65E5\u671F\u7B5B\u9009\uFF0C\u683C\u5F0F\u5982 YYYY-MM-DD"),
+      before: z2.string().optional().describe("\u622A\u6B62\u65E5\u671F\u7B5B\u9009\uFF0C\u683C\u5F0F\u5982 YYYY-MM-DD"),
+      page: z2.number().optional().default(1).describe("\u5F53\u524D\u9875\u7801\uFF0C\u4ECE 1 \u5F00\u59CB\uFF0C\u9ED8\u8BA4 1"),
+      limit: z2.number().optional().default(10).describe("\u6BCF\u9875\u62C9\u53D6\u6761\u6570\uFF0C\u9ED8\u8BA4 10")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const result = await imapService2.searchEmails({
+          mailbox: args.mailbox,
+          query: args.query,
+          from: args.from,
+          to: args.to,
+          subject: args.subject,
+          unseenOnly: args.unseenOnly,
+          flaggedOnly: args.flaggedOnly,
+          hasAttachment: args.hasAttachment,
+          since: args.since,
+          before: args.before,
+          page: args.page,
+          limit: args.limit
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u68C0\u7D22\u90AE\u4EF6\u5217\u8868\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_email_detail",
+    "\u6839\u636E\u90AE\u4EF6\u5168\u5C40 UID \u83B7\u53D6\u5355\u5C01\u90AE\u4EF6\u7684\u5B8C\u6574\u6B63\u6587\u5185\u5BB9\u4E0E\u9644\u4EF6\u6E05\u5355",
+    {
+      account: z2.string().optional().describe("\u6536\u4FE1\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      uid: z2.number().describe("\u90AE\u4EF6\u7684\u552F\u4E00 UID \u6807\u8BC6\u7B26"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u90AE\u7BB1\u6587\u4EF6\u5939\u540D\u79F0\uFF0C\u9ED8\u8BA4\u4E3A INBOX")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const detail = await imapService2.getEmailDetail(args.uid, args.mailbox);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(detail, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u83B7\u53D6\u90AE\u4EF6\u8BE6\u60C5\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_mailboxes",
+    "\u83B7\u53D6\u5F53\u524D\u90AE\u7BB1\u670D\u52A1\u7684\u6240\u6709\u53EF\u7528\u6587\u4EF6\u5939/\u76EE\u5F55\u5217\u8868\uFF08\u5982 INBOX, Sent, Trash \u7B49\uFF09",
+    {
+      account: z2.string().optional().describe("\u6536\u4FE1\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const mailboxes = await imapService2.listMailboxes();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(mailboxes, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u83B7\u53D6\u90AE\u7BB1\u76EE\u5F55\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "download_attachment",
+    "\u5C06\u6307\u5B9A\u90AE\u4EF6\u7684\u9644\u4EF6\u6309\u9700\u63D0\u53D6\u5E76\u5B89\u5168\u4FDD\u5B58\u81F3\u672C\u5730\u53D7\u7BA1\u6C99\u7BB1\u76EE\u5F55\uFF0C\u8FD4\u56DE\u7269\u7406\u7EDD\u5BF9\u8DEF\u5F84\u4E0E file:/// \u76F4\u8FBE URI",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      uid: z2.number().describe("\u90AE\u4EF6\u7684\u552F\u4E00 UID \u6807\u8BC6\u7B26"),
+      attachmentId: z2.string().describe("\u5F85\u4E0B\u8F7D\u9644\u4EF6\u7684\u6807\u8BC6 ID\uFF08\u5BF9\u5E94 get_email_detail \u8FD4\u56DE\u7684\u9644\u4EF6 id\uFF0C\u5982 '0'\uFF09\u6216\u9644\u4EF6\u6587\u4EF6\u540D"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u539F\u90AE\u4EF6\u6240\u5728\u90AE\u7BB1\u6587\u4EF6\u5939\u540D\u79F0\u6216\u522B\u540D\uFF0C\u9ED8\u8BA4\u4E3A INBOX")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const result = await imapService2.downloadAttachment(
+          args.uid,
+          args.attachmentId,
+          args.mailbox
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u4E0B\u8F7D\u9644\u4EF6\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "mark_email_read",
+    "\u5BF9\u5355\u5C01\u6216\u6279\u91CF\u90AE\u4EF6\u8BBE\u7F6E\u5DF2\u8BFB\u6216\u672A\u8BFB\u6807\u8BB0\uFF08\\Seen\uFF09\uFF0C\u534F\u52A9\u5B8C\u6210\u5F85\u529E\u90AE\u4EF6\u5206\u8BCA\u6D41\u8F6C",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      uids: z2.union([z2.number(), z2.array(z2.number())]).describe("\u5355\u5C01\u90AE\u4EF6 UID\uFF08\u6570\u5B57\uFF09\u6216\u6279\u91CF\u90AE\u4EF6 UID \u6570\u7EC4\uFF08\u5982 [101, 102]\uFF09"),
+      read: z2.boolean().optional().default(true).describe("\u662F\u5426\u6807\u8BB0\u4E3A\u5DF2\u8BFB\uFF08true \u4E3A\u5DF2\u8BFB\uFF0Cfalse \u4E3A\u672A\u8BFB\uFF09\uFF0C\u9ED8\u8BA4\u4E3A true"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u76EE\u6807\u90AE\u7BB1\u6587\u4EF6\u5939\u522B\u540D\u6216\u7269\u7406\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A INBOX")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const result = await imapService2.markEmailRead(
+          args.uids,
+          args.read,
+          args.mailbox
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u6807\u8BB0\u5DF2\u8BFB\u72B6\u6001\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "flag_email",
+    "\u5BF9\u5355\u5C01\u6216\u6279\u91CF\u90AE\u4EF6\u8BBE\u7F6E\u6216\u53D6\u6D88\u91CD\u8981\u661F\u6807\u6807\u8BB0\uFF08\\Flagged\uFF09\uFF0C\u7528\u4E8E\u91CD\u70B9\u5173\u6CE8\u6216\u5F85\u529E\u6807\u8BB0",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      uids: z2.union([z2.number(), z2.array(z2.number())]).describe("\u5355\u5C01\u90AE\u4EF6 UID\uFF08\u6570\u5B57\uFF09\u6216\u6279\u91CF\u90AE\u4EF6 UID \u6570\u7EC4\uFF08\u5982 [101, 102]\uFF09"),
+      flagged: z2.boolean().optional().default(true).describe("\u662F\u5426\u8BBE\u7F6E\u661F\u6807\uFF08true \u4E3A\u661F\u6807\u7F6E\u9876\uFF0Cfalse \u4E3A\u53D6\u6D88\u661F\u6807\uFF09\uFF0C\u9ED8\u8BA4\u4E3A true"),
+      mailbox: z2.string().optional().default("INBOX").describe("\u76EE\u6807\u90AE\u7BB1\u6587\u4EF6\u5939\u522B\u540D\u6216\u7269\u7406\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A INBOX")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const result = await imapService2.flagEmail(
+          args.uids,
+          args.flagged,
+          args.mailbox
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u8BBE\u7F6E\u661F\u6807\u72B6\u6001\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "move_email",
+    "\u5C06\u5355\u5C01\u6216\u6279\u91CF\u90AE\u4EF6\u79FB\u52A8\u81F3\u76EE\u6807\u6587\u4EF6\u5939\uFF08\u5982\u5F52\u6863\u81F3 archive\uFF09\uFF1B\u5F7B\u5E95\u7981\u7528\u7269\u7406\u786C\u5220\u9664\uFF0C\u5220\u9664\u90AE\u4EF6\u8BF7\u6307\u5B9A targetMailbox \u4E3A trash \u8FDB\u884C\u5B89\u5168\u8F6F\u5220\u9664",
+    {
+      account: z2.string().optional().describe("\u90AE\u7BB1\u8D26\u6237\u753B\u50CF\u6807\u8BC6\uFF0C\u7F3A\u7701\u65F6\u4F7F\u7528\u9ED8\u8BA4\u8D26\u6237"),
+      uids: z2.union([z2.number(), z2.array(z2.number())]).describe("\u5355\u5C01\u90AE\u4EF6 UID\uFF08\u6570\u5B57\uFF09\u6216\u6279\u91CF\u90AE\u4EF6 UID \u6570\u7EC4\uFF08\u5982 [101, 102]\uFF09"),
+      targetMailbox: z2.string().describe("\u76EE\u6807\u90AE\u7BB1\u6587\u4EF6\u5939\u522B\u540D\u6216\u7269\u7406\u8DEF\u5F84\uFF08\u5982 trash \u8FDB\u884C\u8F6F\u5220\u9664\uFF0C\u6216 archive \u5F52\u6863\uFF09"),
+      sourceMailbox: z2.string().optional().default("INBOX").describe("\u6E90\u90AE\u7BB1\u6587\u4EF6\u5939\u522B\u540D\u6216\u7269\u7406\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A INBOX")
+    },
+    async (args) => {
+      try {
+        const imapService2 = accountManager.getImapService(args.account);
+        const result = await imapService2.moveEmail(
+          args.uids,
+          args.targetMailbox,
+          args.sourceMailbox
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          isError: true,
+          content: [{ type: "text", text: `\u79FB\u52A8\u90AE\u4EF6\u5931\u8D25: ${message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/index.ts
+async function main() {
+  const server = new McpServer({
+    name: "mcp-server-email",
+    version: "1.0.1"
+  });
+  registerEmailTools(server);
+  const args = process.argv.slice(2);
+  let transportMode = config.MCP_TRANSPORT;
+  let port = config.MCP_PORT;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--transport" && args[i + 1]) {
+      transportMode = args[i + 1] === "sse" ? "sse" : "stdio";
+      i++;
+    } else if (args[i] === "--port" && args[i + 1]) {
+      port = parseInt(args[i + 1], 10) || 3e3;
+      i++;
+    }
+  }
+  if (transportMode === "sse") {
+    const sessions = /* @__PURE__ */ new Map();
+    const httpServer = http.createServer(async (req, res) => {
+      const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+      }
+      if (url.pathname === "/sse") {
+        const transport = new SSEServerTransport("/messages", res);
+        sessions.set(transport.sessionId, transport);
+        res.on("close", () => {
+          sessions.delete(transport.sessionId);
+          console.error(`[MCP Email Server] SSE \u4F1A\u8BDD\u5DF2\u65AD\u5F00: ${transport.sessionId}`);
+        });
+        await server.connect(transport);
+        console.error(`[MCP Email Server] SSE \u4F20\u8F93\u8FDE\u63A5\u5DF2\u5EFA\u7ACB: ${transport.sessionId}`);
+      } else if (url.pathname === "/messages" && req.method === "POST") {
+        const sessionId = url.searchParams.get("sessionId");
+        const transport = sessionId ? sessions.get(sessionId) : sessions.values().next().value || null;
+        if (transport) {
+          await transport.handlePostMessage(req, res);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" }).end("\u65E0\u6548\u6216\u672A\u627E\u5230\u5BF9\u5E94\u7684 SSE \u4F20\u8F93\u4F1A\u8BDD");
+        }
+      } else if (url.pathname === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            status: "ok",
+            activeSessions: sessions.size,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      } else {
+        res.writeHead(404).end("Not Found");
+      }
+    });
+    httpServer.listen(port, () => {
+      console.error(`[MCP Email Server] SSE \u6A21\u5F0F\u6B63\u5728\u76D1\u542C\u7AEF\u53E3: ${port}`);
+    });
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[MCP Email Server] Stdio \u4F20\u8F93\u5DF2\u5C31\u7EEA\uFF0C\u6B63\u5728\u76D1\u542C\u6807\u51C6\u8F93\u5165\u8F93\u51FA");
+  }
+}
+main().catch((err) => {
+  console.error("[MCP Email Server \u5D29\u6E83]", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map