@gnidreve/classic-imap-smtp-mcp 0.3.0

package/dist/main.js

@@ -0,0 +1,2924 @@
+#!/usr/bin/env node
+
+// src/bin/main.ts
+import { existsSync, mkdirSync, writeFileSync as writeFileSync5 } from "fs";
+import { dirname } from "path";
+
+// src/config/loader.ts
+import { readFileSync, statSync } from "fs";
+import { parse as parseToml } from "smol-toml";
+
+// src/lib/errors.ts
+var McpMailError = class extends Error {
+  constructor(code, message, details, imapResponse) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.imapResponse = imapResponse;
+    this.name = new.target.name;
+  }
+  code;
+  details;
+  imapResponse;
+  toResult() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.details ? { details: this.details } : {},
+      ...this.imapResponse ? { imap_response: this.imapResponse } : {}
+    };
+  }
+};
+var AuthError = class extends McpMailError {
+  constructor(message = "Authentication failed", details) {
+    super("AUTH_FAILED", message, details);
+  }
+};
+var MailboxNotFoundError = class extends McpMailError {
+  constructor(mailbox) {
+    super("MAILBOX_NOT_FOUND", `Mailbox not found: ${mailbox}`, { mailbox });
+  }
+};
+var UidNotFoundError = class extends McpMailError {
+  constructor(uid, mailbox) {
+    super("UID_NOT_FOUND", `UID ${uid} not found in ${mailbox}`, { uid, mailbox });
+  }
+};
+var AttachmentNotFoundError = class extends McpMailError {
+  constructor(ref) {
+    super("ATTACHMENT_NOT_FOUND", `Attachment not found: ${ref}`, { ref });
+  }
+};
+var AccountNotFoundError = class extends McpMailError {
+  constructor(account) {
+    super("ACCOUNT_NOT_FOUND", `Account not configured: ${account}`, { account });
+  }
+};
+var RateLimitError = class extends McpMailError {
+  constructor(message = "Rate limit exceeded") {
+    super("RATE_LIMITED", message);
+  }
+};
+var TlsError = class extends McpMailError {
+  constructor(message, details) {
+    super("TLS_ERROR", message, details);
+  }
+};
+var ConfigError = class extends McpMailError {
+  constructor(message, details) {
+    super("CONFIG_ERROR", message, details);
+  }
+};
+var PermissionError = class extends McpMailError {
+  constructor(message, details) {
+    super("PERMISSION_DENIED", message, details);
+  }
+};
+var ImapProtocolError = class extends McpMailError {
+  constructor(message, imapResponse) {
+    super("IMAP_PROTOCOL_ERROR", message, void 0, imapResponse);
+  }
+};
+var SmtpRelayError = class extends McpMailError {
+  constructor(message, details) {
+    super("SMTP_RELAY_ERROR", message, details);
+  }
+};
+
+// src/config/providers.ts
+var PROVIDERS = {
+  "gmail.com": {
+    imap_host: "imap.gmail.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.gmail.com",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "outlook.com": {
+    imap_host: "outlook.office365.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.office365.com",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "hotmail.com": {
+    imap_host: "outlook.office365.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.office365.com",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "live.com": {
+    imap_host: "outlook.office365.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.office365.com",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "icloud.com": {
+    imap_host: "imap.mail.me.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.mail.me.com",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "me.com": {
+    imap_host: "imap.mail.me.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.mail.me.com",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "yahoo.com": {
+    imap_host: "imap.mail.yahoo.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.mail.yahoo.com",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "fastmail.com": {
+    imap_host: "imap.fastmail.com",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.fastmail.com",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "posteo.de": {
+    imap_host: "posteo.de",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "posteo.de",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "mailbox.org": {
+    imap_host: "imap.mailbox.org",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.mailbox.org",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "gmx.net": {
+    imap_host: "imap.gmx.net",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "mail.gmx.net",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "gmx.de": {
+    imap_host: "imap.gmx.net",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "mail.gmx.net",
+    smtp_port: 465,
+    smtp_tls: "implicit"
+  },
+  "web.de": {
+    imap_host: "imap.web.de",
+    imap_port: 993,
+    imap_tls: "implicit",
+    smtp_host: "smtp.web.de",
+    smtp_port: 587,
+    smtp_tls: "starttls"
+  },
+  "proton.me": {
+    imap_host: "127.0.0.1",
+    imap_port: 1143,
+    imap_tls: "starttls",
+    smtp_host: "127.0.0.1",
+    smtp_port: 1025,
+    smtp_tls: "starttls"
+  }
+};
+function detectProvider(email) {
+  const domain = email.split("@")[1]?.toLowerCase();
+  return domain ? PROVIDERS[domain] : void 0;
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var tlsModeSchema = z.union([
+  z.literal("implicit"),
+  z.literal("starttls"),
+  z.literal("none")
+]);
+var accountSchema = z.object({
+  name: z.string().min(1),
+  user: z.string().min(1),
+  pass: z.string().min(1),
+  from_name: z.string().optional(),
+  imap_host: z.string().optional(),
+  // optional bei Auto-Detect-Providern
+  imap_port: z.number().int().positive().default(993),
+  imap_tls: tlsModeSchema.default("implicit"),
+  smtp_host: z.string().optional(),
+  smtp_port: z.number().int().positive().default(465),
+  smtp_tls: tlsModeSchema.default("implicit"),
+  verify_tls: z.boolean().default(true)
+});
+var limitsSchema = z.object({
+  smtp_per_minute: z.number().int().positive().default(10),
+  imap_ops_per_second: z.number().int().positive().default(100)
+});
+var fileConfigSchema = z.object({
+  default_account: z.string().optional(),
+  limits: limitsSchema.default({ smtp_per_minute: 10, imap_ops_per_second: 100 }),
+  accounts: z.array(accountSchema).min(1)
+});
+
+// src/config/xdg.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+var APP = "classic-imap-smtp-mcp";
+function defaultConfigPath() {
+  if (platform() === "win32") {
+    const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, APP, "config.toml");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+  return join(xdg, APP, "config.toml");
+}
+
+// src/config/loader.ts
+var ENV = "CLASSIC_IMAP_SMTP_";
+function loadFromEnv() {
+  const user = process.env[`${ENV}USER`];
+  const pass = process.env[`${ENV}PASS`];
+  if (!user || !pass) return null;
+  const preset = detectProvider(user);
+  const raw = {
+    name: "default",
+    user,
+    pass,
+    from_name: process.env[`${ENV}FROM_NAME`],
+    imap_host: process.env[`${ENV}IMAP_HOST`] ?? preset?.imap_host,
+    imap_port: numEnv(`${ENV}IMAP_PORT`) ?? preset?.imap_port ?? 993,
+    imap_tls: process.env[`${ENV}IMAP_TLS`] ?? preset?.imap_tls ?? "implicit",
+    smtp_host: process.env[`${ENV}SMTP_HOST`] ?? preset?.smtp_host,
+    smtp_port: numEnv(`${ENV}SMTP_PORT`) ?? preset?.smtp_port ?? 465,
+    smtp_tls: process.env[`${ENV}SMTP_TLS`] ?? preset?.smtp_tls ?? "implicit",
+    verify_tls: process.env[`${ENV}VERIFY_TLS`] !== "false"
+  };
+  const account = accountSchema.parse(normalizeTls(raw));
+  return { mode: "env", defaultAccount: "default", accounts: /* @__PURE__ */ new Map([["default", account]]) };
+}
+function loadFromFile(path) {
+  let text;
+  try {
+    checkPermissions(path);
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err instanceof PermissionError) throw err;
+    throw new ConfigError(`Cannot read config file: ${path}`, { cause: String(err) });
+  }
+  let parsed;
+  try {
+    parsed = fileConfigSchema.parse(parseToml(text));
+  } catch (err) {
+    throw new ConfigError("Invalid config file", { cause: String(err) });
+  }
+  const accounts = /* @__PURE__ */ new Map();
+  for (const acc of parsed.accounts) {
+    const preset = detectProvider(acc.user);
+    accounts.set(acc.name, {
+      ...acc,
+      imap_host: acc.imap_host ?? preset?.imap_host,
+      smtp_host: acc.smtp_host ?? preset?.smtp_host
+    });
+  }
+  const defaultAccount = parsed.default_account ?? parsed.accounts[0].name;
+  return { mode: "config-file", defaultAccount, accounts, configPath: path };
+}
+function loadConfig(explicitPath) {
+  const fromEnv = loadFromEnv();
+  if (fromEnv) return fromEnv;
+  const path = explicitPath ?? defaultConfigPath();
+  return loadFromFile(path);
+}
+function checkPermissions(path) {
+  if (process.platform === "win32") return;
+  const mode = statSync(path).mode & 511;
+  if (mode & 63) {
+    throw new PermissionError(
+      `Config file ${path} is too permissive (mode ${mode.toString(8)}); expected 0600`,
+      { path, mode: mode.toString(8) }
+    );
+  }
+}
+function numEnv(key) {
+  const v = process.env[key];
+  return v ? Number.parseInt(v, 10) : void 0;
+}
+function normalizeTls(raw) {
+  const map = (v) => v === "true" || v === true ? "implicit" : v === "false" || v === false ? "none" : v;
+  return { ...raw, imap_tls: map(raw.imap_tls), smtp_tls: map(raw.smtp_tls) };
+}
+
+// src/connections/imap-pool.ts
+import { ImapFlow } from "imapflow";
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 6e4;
+var IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+var ImapPool = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  config;
+  logger;
+  connections = /* @__PURE__ */ new Map();
+  async acquire(account) {
+    const existing = this.connections.get(account);
+    if (existing?.client.usable) {
+      existing.lastUsed = Date.now();
+      return existing.client;
+    }
+    if (existing) {
+      try {
+        await existing.client.logout();
+      } catch {
+      }
+      this.connections.delete(account);
+    }
+    const accConfig = this.config.accounts.get(account);
+    if (!accConfig) {
+      throw new ImapProtocolError(`Account ${account} not configured`);
+    }
+    const client = await this.connectWithRetry(accConfig);
+    this.connections.set(account, { client, lastUsed: Date.now() });
+    return client;
+  }
+  async connectWithRetry(acc, attempt = 0) {
+    try {
+      const opts = {
+        // biome-ignore lint/style/noNonNullAssertion: config validated at load
+        host: acc.imap_host,
+        port: acc.imap_port,
+        auth: {
+          user: acc.user,
+          pass: acc.pass
+        },
+        logger: false,
+        secure: acc.imap_tls !== "starttls" && acc.imap_tls !== "none"
+      };
+      if (acc.imap_tls === "none") {
+        opts.disableAutoIdle = true;
+      }
+      if (!acc.verify_tls) {
+        opts.tls = { rejectUnauthorized: false };
+      }
+      const client = new ImapFlow(opts);
+      await client.connect();
+      this.logger.info({ account: acc.name }, "IMAP connected");
+      return client;
+    } catch (err) {
+      const error = err;
+      if (error.message?.includes("TLS") || error.message?.includes("certificate")) {
+        throw new TlsError(`IMAP TLS error: ${error.message}`);
+      }
+      if (error.message?.includes("authentication") || error.message?.includes("login") || error.message?.includes("Auth")) {
+        throw new AuthError(`IMAP authentication failed: ${error.message}`);
+      }
+      if (attempt < MAX_RETRIES) {
+        const delay = Math.min(BASE_DELAY_MS * 2 ** attempt, MAX_DELAY_MS);
+        this.logger.warn({ account: acc.name, attempt: attempt + 1, delay }, "IMAP reconnect");
+        await sleep(delay);
+        return this.connectWithRetry(acc, attempt + 1);
+      }
+      throw new ImapProtocolError(`Failed to connect to IMAP: ${error.message}`);
+    }
+  }
+  async pruneIdle() {
+    const now = Date.now();
+    for (const [account, entry] of this.connections) {
+      if (now - entry.lastUsed > IDLE_TIMEOUT_MS) {
+        this.logger.info({ account }, "Closing idle IMAP connection");
+        try {
+          await entry.client.logout();
+        } catch {
+        }
+        this.connections.delete(account);
+      }
+    }
+  }
+  async closeAll() {
+    for (const [account, entry] of this.connections) {
+      try {
+        if (entry.client.usable) await entry.client.logout();
+      } catch (err) {
+        this.logger.warn({ account, err }, "Error closing IMAP connection");
+      }
+    }
+    this.connections.clear();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/connections/smtp-pool.ts
+import nodemailer from "nodemailer";
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var DEFAULT_RATE_LIMIT = 10;
+var SmtpPool = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  config;
+  logger;
+  transports = /* @__PURE__ */ new Map();
+  rateBuckets = /* @__PURE__ */ new Map();
+  // Liefert einen nodemailer-Transporter für den Account.
+  async acquire(account) {
+    this.checkRateLimit(account);
+    const existing = this.transports.get(account);
+    if (existing) return existing;
+    const accConfig = this.config.accounts.get(account);
+    if (!accConfig) {
+      throw new SmtpRelayError(`Account ${account} not configured`);
+    }
+    const transport = await this.createTransport(accConfig);
+    this.transports.set(account, transport);
+    return transport;
+  }
+  checkRateLimit(account) {
+    const limit = DEFAULT_RATE_LIMIT;
+    const bucket = this.rateBuckets.get(account) ?? { tokens: limit, lastRefill: Date.now() };
+    const now = Date.now();
+    const elapsed = now - bucket.lastRefill;
+    if (elapsed >= RATE_LIMIT_WINDOW_MS) {
+      bucket.tokens = limit;
+      bucket.lastRefill = now;
+    }
+    if (bucket.tokens <= 0) {
+      throw new RateLimitError(`SMTP rate limit (${limit}/minute) reached for account ${account}`);
+    }
+    bucket.tokens--;
+    this.rateBuckets.set(account, bucket);
+  }
+  async createTransport(acc) {
+    try {
+      const tlsOpts = {};
+      if (!acc.verify_tls) {
+        tlsOpts.rejectUnauthorized = false;
+      }
+      const transporter = nodemailer.createTransport({
+        // biome-ignore lint/style/noNonNullAssertion: config validated at load
+        host: acc.smtp_host,
+        port: acc.smtp_port,
+        secure: acc.smtp_tls === "implicit",
+        auth: {
+          user: acc.user,
+          pass: acc.pass
+        },
+        tls: tlsOpts,
+        // STARTTLS: wird von nodemailer automatisch bei secure=false und Port 587/25 verwendet
+        pool: true,
+        maxConnections: 1,
+        maxMessages: 100,
+        logger: false
+      });
+      this.logger.info({ account: acc.name }, "SMTP transport created");
+      return transporter;
+    } catch (err) {
+      const error = err;
+      if (error.message?.includes("auth") || error.message?.includes("login")) {
+        throw new AuthError(`SMTP authentication failed: ${error.message}`);
+      }
+      throw new SmtpRelayError(`Failed to create SMTP transport: ${error.message}`);
+    }
+  }
+  async closeAll() {
+    for (const [account, transport] of this.transports) {
+      try {
+        transport.close();
+      } catch (err) {
+        this.logger.warn({ account, err }, "Error closing SMTP transport");
+      }
+    }
+    this.transports.clear();
+    this.rateBuckets.clear();
+  }
+};
+
+// src/server/logging.ts
+import { pino } from "pino";
+var REDACT_KEYS = ["pass", "password", "token", "secret", "apikey", "apiKey"];
+function createLogger(opts = {}) {
+  const level = opts.level ?? "info";
+  const format = opts.format ?? "json";
+  if (format === "pretty") {
+    return pino({
+      level,
+      redact: { paths: REDACT_KEYS.flatMap((k) => [k, `*.${k}`, `*.*.${k}`]), censor: "***" },
+      transport: { target: "pino-pretty", options: { destination: 2 } }
+    });
+  }
+  return pino({
+    level,
+    redact: { paths: REDACT_KEYS.flatMap((k) => [k, `*.${k}`, `*.*.${k}`]), censor: "***" }
+  });
+}
+
+// src/server/options.ts
+function parseArgs(argv) {
+  const opts = {
+    safe: false,
+    readonly: false,
+    noImap: false,
+    noSmtp: false,
+    logLevel: "info",
+    logFormat: "json"
+  };
+  let subcommand;
+  let subcommandArg;
+  let help = false;
+  let version = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "init" || arg === "test" || arg === "list-tools") {
+      subcommand = arg;
+      if (arg === "test" && argv[i + 1] && !argv[i + 1]?.startsWith("-")) {
+        subcommandArg = argv[++i];
+      }
+    } else if (arg === "--safe") opts.safe = true;
+    else if (arg === "--readonly") opts.readonly = true;
+    else if (arg === "--no-imap") opts.noImap = true;
+    else if (arg === "--no-smtp") opts.noSmtp = true;
+    else if (arg === "-h" || arg === "--help") help = true;
+    else if (arg === "-V" || arg === "--version") version = true;
+    else if (arg.startsWith("--allow-tools=")) opts.allowTools = csv(arg);
+    else if (arg.startsWith("--deny-tools=")) opts.denyTools = csv(arg);
+    else if (arg.startsWith("--account=")) opts.account = val(arg);
+    else if (arg.startsWith("--config=")) opts.configPath = val(arg);
+    else if (arg.startsWith("--log-level=")) opts.logLevel = val(arg);
+    else if (arg.startsWith("--log-format="))
+      opts.logFormat = val(arg) === "pretty" ? "pretty" : "json";
+  }
+  return { subcommand, subcommandArg, options: opts, help, version };
+}
+var val = (arg) => arg.slice(arg.indexOf("=") + 1);
+var csv = (arg) => val(arg).split(",").map((s) => s.trim()).filter(Boolean);
+
+// src/server/registry.ts
+var READONLY_TOOLS = /* @__PURE__ */ new Set([
+  "imap_list_mailboxes",
+  "imap_status_mailbox",
+  "imap_list_messages",
+  "imap_get_message",
+  "imap_get_message_headers",
+  "imap_get_message_raw",
+  "imap_get_messages_bulk",
+  "imap_search",
+  "imap_download_attachment",
+  "imap_get_thread",
+  "imap_get_quota",
+  "imap_check_capabilities",
+  "smtp_verify_connection",
+  "account_list",
+  "meta_health",
+  "meta_server_info"
+]);
+var DELETE_TOOLS = /* @__PURE__ */ new Set([
+  "imap_delete_message",
+  "imap_expunge",
+  "imap_delete_mailbox"
+]);
+function matchesAny(name, patterns) {
+  return patterns.some((p) => p.endsWith("*") ? name.startsWith(p.slice(0, -1)) : name === p);
+}
+function passesFeatureFlags(t, o) {
+  if (o.noImap && t.category.startsWith("imap")) return false;
+  if (o.noSmtp && t.category === "smtp") return false;
+  if (o.readonly && !READONLY_TOOLS.has(t.name)) return false;
+  if (o.safe && DELETE_TOOLS.has(t.name)) return false;
+  return true;
+}
+function resolveActiveTools(all, o) {
+  const active = /* @__PURE__ */ new Set();
+  for (const t of all) if (passesFeatureFlags(t, o)) active.add(t.name);
+  if (o.allowTools?.length) {
+    for (const t of all) if (matchesAny(t.name, o.allowTools)) active.add(t.name);
+  }
+  if (o.denyTools?.length) {
+    for (const name of [...active]) if (matchesAny(name, o.denyTools)) active.delete(name);
+  }
+  return all.filter((t) => active.has(t.name));
+}
+
+// src/server/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/imap-read/check-capabilities.ts
+import { z as z2 } from "zod";
+
+// src/tools/_types.ts
+function defineTool(def) {
+  return def;
+}
+
+// src/tools/imap-read/check-capabilities.ts
+var check_capabilities_default = defineTool({
+  name: "imap_check_capabilities",
+  description: "Server CAPABILITY-Liste",
+  category: "imap-read",
+  inputSchema: z2.object({
+    account: z2.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const caps = [...client.capabilities.keys()];
+    return { capabilities: caps };
+  }
+});
+
+// src/tools/imap-read/download-attachment.ts
+import { writeFileSync } from "fs";
+import { z as z3 } from "zod";
+var download_attachment_default = defineTool({
+  name: "imap_download_attachment",
+  description: "Gezielt eine MIME-Part extrahieren (Pfad oder Base64)",
+  category: "imap-read",
+  inputSchema: z3.object({
+    mailbox: z3.string().min(1).describe("Mailbox path"),
+    uid: z3.number().int().positive().describe("Message UID"),
+    partId: z3.string().min(1).describe("MIME part ID (e.g. '1', '2.1')"),
+    savePath: z3.string().optional().describe("Local path to save the attachment"),
+    account: z3.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const msg = await client.fetchOne(input.uid, {
+      uid: true,
+      bodyParts: [input.partId],
+      bodyStructure: true
+    });
+    if (!msg) throw new UidNotFoundError(input.uid, input.mailbox);
+    const part = msg.bodyParts?.get(input.partId);
+    if (!part) throw new AttachmentNotFoundError(`Part ${input.partId}`);
+    let contentType = "application/octet-stream";
+    let filename = `attachment-${input.partId}`;
+    if (msg.bodyStructure) {
+      contentType = msg.bodyStructure.type || contentType;
+      filename = msg.bodyStructure.parameters?.name || msg.bodyStructure.parameters?.filename || filename;
+    }
+    const buffer = Buffer.from(part);
+    const size = buffer.length;
+    const base64 = buffer.toString("base64");
+    if (input.savePath) {
+      writeFileSync(input.savePath, buffer);
+    }
+    return {
+      partId: input.partId,
+      ...filename ? { filename } : {},
+      contentType,
+      size,
+      ...input.savePath ? { savedPath: input.savePath } : { base64 }
+    };
+  }
+});
+
+// src/tools/imap-read/get-message-headers.ts
+import { z as z4 } from "zod";
+var get_message_headers_default = defineTool({
+  name: "imap_get_message_headers",
+  description: "Nur Header einer Mail",
+  category: "imap-read",
+  inputSchema: z4.object({
+    mailbox: z4.string().min(1).describe("Mailbox path"),
+    uid: z4.number().int().positive().describe("Message UID"),
+    account: z4.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mailbox = await client.mailboxOpen(input.mailbox);
+    if (!mailbox) throw new MailboxNotFoundError(input.mailbox);
+    const msg = await client.fetchOne(input.uid, {
+      uid: true,
+      headers: true
+    });
+    if (!msg) throw new UidNotFoundError(input.uid, input.mailbox);
+    const rawHeaders = msg.headers?.toString() ?? "";
+    const headers = {};
+    const lines = rawHeaders.split("\r\n");
+    let currentKey = null;
+    let currentValue = null;
+    for (const line of lines) {
+      if ((line.startsWith(" ") || line.startsWith("	")) && currentKey) {
+        if (currentValue) {
+          currentValue += ` ${line.trim()}`;
+        }
+        continue;
+      }
+      if (currentKey && currentValue) {
+        const existing = headers[currentKey];
+        if (existing) {
+          if (Array.isArray(existing)) {
+            existing.push(currentValue);
+          } else {
+            headers[currentKey] = [existing, currentValue];
+          }
+        } else {
+          headers[currentKey] = currentValue;
+        }
+      }
+      const colonIdx = line.indexOf(":");
+      if (colonIdx > 0) {
+        currentKey = line.slice(0, colonIdx).trim();
+        currentValue = line.slice(colonIdx + 1).trim();
+      } else {
+        currentKey = null;
+        currentValue = null;
+      }
+    }
+    if (currentKey && currentValue) {
+      const existing = headers[currentKey];
+      if (existing) {
+        if (Array.isArray(existing)) {
+          existing.push(currentValue);
+        } else {
+          headers[currentKey] = [existing, currentValue];
+        }
+      } else {
+        headers[currentKey] = currentValue;
+      }
+    }
+    return {
+      uid: msg.uid,
+      headers
+    };
+  }
+});
+
+// src/tools/imap-read/get-message-raw.ts
+import { z as z5 } from "zod";
+var get_message_raw_default = defineTool({
+  name: "imap_get_message_raw",
+  description: "RFC-822 raw source einer Mail",
+  category: "imap-read",
+  inputSchema: z5.object({
+    mailbox: z5.string().min(1).describe("Mailbox path"),
+    uid: z5.number().int().positive().describe("Message UID"),
+    account: z5.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mailbox = await client.mailboxOpen(input.mailbox);
+    if (!mailbox) throw new MailboxNotFoundError(input.mailbox);
+    const msg = await client.fetchOne(input.uid, {
+      uid: true,
+      source: true
+    });
+    if (!msg) throw new UidNotFoundError(input.uid, input.mailbox);
+    return {
+      uid: msg.uid,
+      rfc822: msg.source?.toString() ?? ""
+    };
+  }
+});
+
+// src/tools/imap-read/get-message.ts
+import { z as z6 } from "zod";
+
+// src/lib/mime.ts
+import { simpleParser } from "mailparser";
+async function parseMime(raw) {
+  const parsed = await simpleParser(raw);
+  const body = {};
+  if (parsed.text) body.text = parsed.text;
+  if (parsed.html) body.html = parsed.html;
+  const attachments = (parsed.attachments || []).map(
+    (a, idx) => {
+      const fn = a.filename || extractFilenameFromHeaders(a.headers);
+      return {
+        partId: a.related ? `related.${idx + 1}` : String(idx + 1),
+        filename: fn ?? `attachment_${idx + 1}`,
+        contentType: a.contentType || "application/octet-stream",
+        size: a.size || a.content.length || 0,
+        ...a.contentId ? { contentId: a.contentId } : {},
+        ...a.contentDisposition === "inline" ? { disposition: "inline" } : a.contentDisposition === "attachment" ? { disposition: "attachment" } : {}
+      };
+    }
+  );
+  return { body, attachments };
+}
+function extractFilenameFromHeaders(headers) {
+  if (!headers) return void 0;
+  const cd = headers.get("content-disposition");
+  if (typeof cd === "string") {
+    const m = cd.match(/filename\*?=(?:[^']*'[^']*')?([^;\s]+)/i);
+    if (m) {
+      try {
+        const captured = m[1];
+        return captured ? decodeURIComponent(captured) : void 0;
+      } catch {
+        return m[1];
+      }
+    }
+    const m2 = cd.match(/filename="?([^";]*)"?/i);
+    if (m2) return m2[1];
+  }
+  return void 0;
+}
+
+// src/tools/imap-read/get-message.ts
+function addressArray(addr) {
+  if (!addr) return [];
+  const list = Array.isArray(addr) ? addr : [addr];
+  const result = [];
+  for (const entry of list) {
+    if (entry && typeof entry === "object") {
+      const e = entry;
+      const addrStr = e.address ?? "";
+      if (addrStr) {
+        result.push({ ...e.name ? { name: e.name } : {}, address: addrStr });
+      }
+    }
+  }
+  return result;
+}
+var get_message_default = defineTool({
+  name: "imap_get_message",
+  description: "Vollst\xE4ndige Mail inkl. geparstem Body + Attachment-Metadaten",
+  category: "imap-read",
+  inputSchema: z6.object({
+    mailbox: z6.string().min(1).describe("Mailbox path"),
+    uid: z6.number().int().positive().describe("Message UID"),
+    account: z6.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mailbox = await client.mailboxOpen(input.mailbox);
+    if (!mailbox) throw new MailboxNotFoundError(input.mailbox);
+    const msg = await client.fetchOne(input.uid, {
+      uid: true,
+      envelope: true,
+      flags: true,
+      size: true,
+      source: true
+    });
+    if (!msg) throw new UidNotFoundError(input.uid, input.mailbox);
+    const raw = msg.source?.toString() ?? "";
+    let parsed;
+    try {
+      parsed = await parseMime(raw);
+    } catch {
+      parsed = { body: {}, attachments: [] };
+    }
+    const enc = msg.envelope;
+    return {
+      envelope: {
+        uid: msg.uid,
+        subject: enc?.subject ?? "",
+        from: addressArray(enc?.from),
+        to: addressArray(enc?.to),
+        ...enc?.cc?.length ? { cc: addressArray(enc.cc) } : {},
+        ...enc?.bcc?.length ? { bcc: addressArray(enc.bcc) } : {},
+        ...enc?.replyTo?.length ? { replyTo: addressArray(enc.replyTo) } : {},
+        date: (enc?.date ?? /* @__PURE__ */ new Date()).toISOString(),
+        ...enc?.messageId ? { messageId: enc.messageId } : {},
+        ...enc?.inReplyTo ? { inReplyTo: enc.inReplyTo } : {},
+        flags: [...msg.flags ?? []],
+        size: msg.size ?? 0,
+        hasAttachments: parsed.attachments.length > 0
+      },
+      ...parsed.body.text ? { text: parsed.body.text } : {},
+      ...parsed.body.html ? { html: parsed.body.html } : {},
+      attachments: parsed.attachments
+    };
+  }
+});
+
+// src/tools/imap-read/get-messages-bulk.ts
+import { z as z7 } from "zod";
+function addressArray2(addr) {
+  if (!addr) return [];
+  const list = Array.isArray(addr) ? addr : [addr];
+  const result = [];
+  for (const entry of list) {
+    if (entry && typeof entry === "object") {
+      const e = entry;
+      const addrStr = e.address ?? "";
+      if (addrStr) {
+        result.push({ ...e.name ? { name: e.name } : {}, address: addrStr });
+      }
+    }
+  }
+  return result;
+}
+var get_messages_bulk_default = defineTool({
+  name: "imap_get_messages_bulk",
+  description: "Bis N UIDs in einem Call holen",
+  category: "imap-read",
+  inputSchema: z7.object({
+    mailbox: z7.string().min(1).describe("Mailbox path"),
+    uids: z7.array(z7.number().int().positive()).min(1).max(500).describe("Message UIDs"),
+    account: z7.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const messages = [];
+    const notFound = [];
+    const uidSet = new Set(input.uids);
+    for await (const msg of client.fetch(input.uids, {
+      uid: true,
+      envelope: true,
+      flags: true,
+      size: true,
+      source: true
+    })) {
+      uidSet.delete(msg.uid);
+      const raw = msg.source?.toString() ?? "";
+      let parsed;
+      try {
+        parsed = await parseMime(raw);
+      } catch {
+        parsed = { body: {}, attachments: [] };
+      }
+      const enc = msg.envelope;
+      messages.push({
+        envelope: {
+          uid: msg.uid,
+          subject: enc?.subject ?? "",
+          from: addressArray2(enc?.from),
+          to: addressArray2(enc?.to),
+          ...enc?.cc?.length ? { cc: addressArray2(enc.cc) } : {},
+          ...enc?.bcc?.length ? { bcc: addressArray2(enc.bcc) } : {},
+          ...enc?.replyTo?.length ? { replyTo: addressArray2(enc.replyTo) } : {},
+          date: (enc?.date ?? /* @__PURE__ */ new Date()).toISOString(),
+          ...enc?.messageId ? { messageId: enc.messageId } : {},
+          ...enc?.inReplyTo ? { inReplyTo: enc.inReplyTo } : {},
+          flags: [...msg.flags ?? []],
+          size: msg.size ?? 0,
+          hasAttachments: parsed.attachments.length > 0
+        },
+        ...parsed.body.text ? { text: parsed.body.text } : {},
+        ...parsed.body.html ? { html: parsed.body.html } : {},
+        attachments: parsed.attachments
+      });
+    }
+    for (const uid of uidSet) notFound.push(uid);
+    return {
+      mailbox: input.mailbox,
+      messages,
+      notFound
+    };
+  }
+});
+
+// src/tools/imap-read/get-quota.ts
+import { z as z8 } from "zod";
+var get_quota_default = defineTool({
+  name: "imap_get_quota",
+  description: "Quota-Info abfragen (RFC 2087)",
+  category: "imap-read",
+  inputSchema: z8.object({
+    account: z8.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const caps = [...client.capabilities.keys()];
+    if (!caps.some((c) => c.toUpperCase() === "QUOTA")) {
+      return { root: "INBOX", usage: 0, limit: -1 };
+    }
+    try {
+      const result = await client.getQuota();
+      if (!result) {
+        return { root: "INBOX", usage: 0, limit: -1 };
+      }
+      const usage = result.storage?.used ?? result.messages?.used ?? 0;
+      const limit = result.storage?.limit ?? result.messages?.limit ?? -1;
+      const resources = [];
+      if (result.storage) {
+        resources.push({
+          name: "STORAGE",
+          usage: result.storage.used,
+          limit: result.storage.limit
+        });
+      }
+      if (result.messages) {
+        resources.push({
+          name: "MESSAGES",
+          usage: result.messages.used,
+          limit: result.messages.limit
+        });
+      }
+      return {
+        root: result.path,
+        usage,
+        limit,
+        ...resources.length > 1 ? { resources } : {}
+      };
+    } catch {
+      return { root: "INBOX", usage: 0, limit: -1 };
+    }
+  }
+});
+
+// src/tools/imap-read/get-thread.ts
+import { z as z9 } from "zod";
+
+// src/lib/threading.ts
+function reconstructThread(messages, rootUid) {
+  if (messages.length === 0) return [];
+  const byUid = /* @__PURE__ */ new Map();
+  const byMessageId = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    byUid.set(msg.uid, msg);
+    if (msg.messageId) {
+      byMessageId.set(msg.messageId, msg);
+    }
+  }
+  const root = byUid.get(rootUid);
+  if (!root) return [];
+  const allMessageIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.messageId) allMessageIds.add(msg.messageId);
+    if (msg.references) for (const ref of msg.references) allMessageIds.add(ref);
+    if (msg.inReplyTo) allMessageIds.add(msg.inReplyTo);
+  }
+  const threadSet = /* @__PURE__ */ new Set();
+  threadSet.add(rootUid);
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [rootUid];
+  while (queue.length > 0) {
+    const currentUid = queue.pop();
+    if (seen.has(currentUid)) continue;
+    seen.add(currentUid);
+    const current = byUid.get(currentUid);
+    if (!current) continue;
+    const relevantIds = /* @__PURE__ */ new Set();
+    if (current.messageId) relevantIds.add(current.messageId);
+    if (current.inReplyTo) relevantIds.add(current.inReplyTo);
+    if (current.references) for (const ref of current.references) relevantIds.add(ref);
+    for (const other of messages) {
+      if (threadSet.has(other.uid)) continue;
+      if (!other.inReplyTo && !other.references) continue;
+      if (other.inReplyTo && relevantIds.has(other.inReplyTo)) {
+        threadSet.add(other.uid);
+        queue.push(other.uid);
+        continue;
+      }
+      if (other.references) {
+        for (const ref of other.references) {
+          if (relevantIds.has(ref)) {
+            threadSet.add(other.uid);
+            queue.push(other.uid);
+            break;
+          }
+        }
+      }
+      if (current.messageId && other.references?.includes(current.messageId)) {
+        threadSet.add(other.uid);
+        queue.push(other.uid);
+      }
+    }
+    if (current.inReplyTo) {
+      const parent = byMessageId.get(current.inReplyTo);
+      if (parent) {
+        threadSet.add(parent.uid);
+        queue.push(parent.uid);
+      }
+    }
+    if (current.references) {
+      for (const ref of current.references) {
+        const refMsg = byMessageId.get(ref);
+        if (refMsg) {
+          threadSet.add(refMsg.uid);
+          queue.push(refMsg.uid);
+        }
+      }
+    }
+  }
+  const result = messages.filter((m) => threadSet.has(m.uid));
+  result.sort((a, b) => a.date.getTime() - b.date.getTime());
+  return result;
+}
+
+// src/tools/imap-read/get-thread.ts
+function addressArray3(addr) {
+  if (!addr) return [];
+  const list = Array.isArray(addr) ? addr : [addr];
+  const result = [];
+  for (const entry of list) {
+    if (entry && typeof entry === "object") {
+      const e = entry;
+      const addrStr = e.address ?? "";
+      if (addrStr) {
+        result.push({ ...e.name ? { name: e.name } : {}, address: addrStr });
+      }
+    }
+  }
+  return result;
+}
+var get_thread_default = defineTool({
+  name: "imap_get_thread",
+  description: "Konversation via In-Reply-To/References rekonstruieren",
+  category: "imap-read",
+  inputSchema: z9.object({
+    mailbox: z9.string().min(1).describe("Mailbox path"),
+    uid: z9.number().int().positive().describe("Root message UID"),
+    account: z9.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const allMessages = [];
+    const extras = /* @__PURE__ */ new Map();
+    for await (const msg of client.fetch("1:*", {
+      uid: true,
+      envelope: true,
+      flags: true,
+      size: true,
+      headers: ["message-id", "in-reply-to", "references"]
+    })) {
+      const enc = msg.envelope;
+      if (!enc) continue;
+      const rawHeaders = msg.headers?.toString() ?? "";
+      const refMatch = rawHeaders.match(/^references:\s*(.*)$/im);
+      const refs = refMatch ? refMatch[1]?.trim().split(/\s+/).filter(Boolean) : void 0;
+      allMessages.push({
+        uid: msg.uid,
+        messageId: enc.messageId ?? void 0,
+        inReplyTo: enc.inReplyTo ?? void 0,
+        references: refs,
+        date: enc.date ?? /* @__PURE__ */ new Date()
+      });
+      extras.set(msg.uid, {
+        subject: enc.subject ?? "",
+        from: addressArray3(enc.from),
+        to: addressArray3(enc.to),
+        ...enc.cc?.length ? { cc: addressArray3(enc.cc) } : {},
+        ...enc.bcc?.length ? { bcc: addressArray3(enc.bcc) } : {},
+        ...enc.replyTo?.length ? { replyTo: addressArray3(enc.replyTo) } : {},
+        date: (enc.date ?? /* @__PURE__ */ new Date()).toISOString(),
+        ...enc.messageId ? { messageId: enc.messageId } : {},
+        ...enc.inReplyTo ? { inReplyTo: enc.inReplyTo } : {},
+        flags: [...msg.flags ?? []],
+        size: msg.size ?? 0,
+        hasAttachments: false
+      });
+    }
+    const thread = reconstructThread(allMessages, input.uid);
+    const root = allMessages.find((m) => m.uid === input.uid);
+    if (!root) throw new UidNotFoundError(input.uid, input.mailbox);
+    const messages = thread.map((m) => ({
+      ...extras.get(m.uid) ?? {}
+    }));
+    return {
+      rootUid: input.uid,
+      mailbox: input.mailbox,
+      messages
+    };
+  }
+});
+
+// src/tools/imap-read/list-mailboxes.ts
+import { z as z10 } from "zod";
+var list_mailboxes_default = defineTool({
+  name: "imap_list_mailboxes",
+  description: "Folder enumerieren mit Special-Use-Flags (RFC 6154)",
+  category: "imap-read",
+  inputSchema: z10.object({
+    account: z10.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mailboxes = await client.list();
+    const result = mailboxes.map((mb) => {
+      const flags = [...mb.flags || []];
+      const specialUse = flags.find(
+        (f) => [
+          "\\Inbox",
+          "\\Sent",
+          "\\Drafts",
+          "\\Trash",
+          "\\Junk",
+          "\\Archive",
+          "\\All",
+          "\\Flagged"
+        ].includes(f)
+      );
+      return {
+        path: mb.path,
+        delimiter: mb.delimiter,
+        flags,
+        ...specialUse ? { specialUse } : {},
+        subscribed: mb.subscribed
+      };
+    });
+    return { mailboxes: result };
+  }
+});
+
+// src/tools/imap-read/list-messages.ts
+import { z as z11 } from "zod";
+function addressArray4(addr) {
+  if (!addr) return [];
+  const list = Array.isArray(addr) ? addr : [addr];
+  const result = [];
+  for (const entry of list) {
+    if (entry && typeof entry === "object") {
+      const e = entry;
+      const addrStr = e.address ?? "";
+      if (addrStr) {
+        result.push({ ...e.name ? { name: e.name } : {}, address: addrStr });
+      }
+    }
+  }
+  return result;
+}
+var list_messages_default = defineTool({
+  name: "imap_list_messages",
+  description: "Paginierte Envelope-Liste in einem Folder",
+  category: "imap-read",
+  inputSchema: z11.object({
+    mailbox: z11.string().min(1).describe("Mailbox path"),
+    page: z11.number().int().positive().default(1).describe("Page number (default: 1)"),
+    pageSize: z11.number().int().positive().max(500).default(50).describe("Messages per page (default: 50, max: 500)"),
+    sort: z11.enum(["date", "subject", "from", "size"]).optional().describe("Sort field"),
+    sortOrder: z11.enum(["asc", "desc"]).default("desc").describe("Sort order (default: desc)"),
+    account: z11.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mailbox = await client.mailboxOpen(input.mailbox);
+    if (!mailbox) {
+      throw new MailboxNotFoundError(input.mailbox);
+    }
+    const total = mailbox.exists;
+    const currentPage = input.page ?? 1;
+    const pageSize = input.pageSize ?? 50;
+    const startNum = (currentPage - 1) * pageSize + 1;
+    const endNum = Math.min(startNum + pageSize - 1, total);
+    if (startNum > total) {
+      return {
+        mailbox: input.mailbox,
+        page: currentPage,
+        pageSize,
+        total,
+        messages: []
+      };
+    }
+    const messages = [];
+    for await (const msg of client.fetch(`${startNum}:${endNum}`, {
+      uid: true,
+      envelope: true,
+      flags: true,
+      size: true
+    })) {
+      const enc = msg.envelope;
+      if (!enc) continue;
+      let hasAttachments = false;
+      if (msg.bodyStructure?.type?.toLowerCase() === "multipart") {
+        hasAttachments = true;
+      }
+      messages.push({
+        uid: msg.uid,
+        seq: msg.seq,
+        subject: enc.subject ?? "",
+        from: addressArray4(enc.from),
+        to: addressArray4(enc.to),
+        ...enc.cc?.length ? { cc: addressArray4(enc.cc) } : {},
+        ...enc.bcc?.length ? { bcc: addressArray4(enc.bcc) } : {},
+        ...enc.replyTo?.length ? { replyTo: addressArray4(enc.replyTo) } : {},
+        date: (enc.date ?? /* @__PURE__ */ new Date()).toISOString(),
+        ...enc.messageId ? { messageId: enc.messageId } : {},
+        ...enc.inReplyTo ? { inReplyTo: enc.inReplyTo } : {},
+        flags: [...msg.flags ?? []],
+        size: msg.size ?? 0,
+        hasAttachments
+      });
+    }
+    return {
+      mailbox: input.mailbox,
+      page: currentPage,
+      pageSize,
+      total,
+      messages
+    };
+  }
+});
+
+// src/tools/imap-read/search.ts
+import { z as z12 } from "zod";
+
+// src/lib/search-builder.ts
+function parseSearchDate(value) {
+  const isoMatch = value.match(/^\d{4}-\d{2}-\d{2}/);
+  if (isoMatch) return new Date(isoMatch[0]);
+  const parsed = new Date(value);
+  if (!Number.isNaN(parsed.getTime())) return parsed;
+  const months = {
+    jan: "01",
+    feb: "02",
+    mar: "03",
+    apr: "04",
+    may: "05",
+    jun: "06",
+    jul: "07",
+    aug: "08",
+    sep: "09",
+    oct: "10",
+    nov: "11",
+    dec: "12"
+  };
+  const parts = value.split("-");
+  if (parts.length === 3) {
+    const day = parts[0].padStart(2, "0");
+    const monKey = parts[1]?.toLowerCase().slice(0, 3);
+    const mon = monKey ? months[monKey] : void 0;
+    const yearRaw = parts[2];
+    const year = yearRaw.length === 2 ? `20${yearRaw}` : yearRaw;
+    if (mon && day) return /* @__PURE__ */ new Date(`${year}-${mon}-${day}`);
+  }
+  throw new Error(
+    `Cannot parse date: ${value}. Use DD-Mon-YYYY (e.g., 21-May-2026) or YYYY-MM-DD.`
+  );
+}
+function buildSearchQuery(criteria) {
+  const query = {};
+  if (criteria.from !== void 0) query.from = criteria.from;
+  if (criteria.to !== void 0) query.to = criteria.to;
+  if (criteria.cc !== void 0) query.cc = criteria.cc;
+  if (criteria.bcc !== void 0) query.bcc = criteria.bcc;
+  if (criteria.subject !== void 0) query.subject = criteria.subject;
+  if (criteria.body !== void 0) query.body = criteria.body;
+  if (criteria.text !== void 0) query.text = criteria.text;
+  if (criteria.since !== void 0) query.since = parseSearchDate(criteria.since);
+  if (criteria.before !== void 0) query.before = parseSearchDate(criteria.before);
+  if (criteria.on !== void 0) query.on = parseSearchDate(criteria.on);
+  if (criteria.sentSince !== void 0) query.sentSince = parseSearchDate(criteria.sentSince);
+  if (criteria.sentBefore !== void 0) query.sentBefore = parseSearchDate(criteria.sentBefore);
+  if (criteria.sentOn !== void 0) query.sentOn = parseSearchDate(criteria.sentOn);
+  if (criteria.larger !== void 0) query.larger = criteria.larger;
+  if (criteria.smaller !== void 0) query.smaller = criteria.smaller;
+  if (criteria.unseen !== void 0) query.unseen = criteria.unseen;
+  if (criteria.seen !== void 0) query.seen = criteria.seen;
+  if (criteria.flagged !== void 0) query.flagged = criteria.flagged;
+  if (criteria.unflagged !== void 0) query.unflagged = criteria.unflagged;
+  if (criteria.answered !== void 0) query.answered = criteria.answered;
+  if (criteria.unanswered !== void 0) query.unanswered = criteria.unanswered;
+  if (criteria.deleted !== void 0) query.deleted = criteria.deleted;
+  if (criteria.undeleted !== void 0) query.undeleted = criteria.undeleted;
+  if (criteria.new !== void 0) query.new = criteria.new;
+  if (criteria.old !== void 0) query.old = criteria.old;
+  if (criteria.recent !== void 0) query.recent = criteria.recent;
+  if (criteria.keyword !== void 0) query.keyword = criteria.keyword;
+  if (criteria.unkeyword !== void 0) query.unkeyword = criteria.unkeyword;
+  return query;
+}
+
+// src/tools/imap-read/search.ts
+var search_default = defineTool({
+  name: "imap_search",
+  description: "Vollst\xE4ndiger RFC-3501-SEARCH-Builder",
+  category: "imap-read",
+  inputSchema: z12.object({
+    mailbox: z12.string().min(1).describe("Mailbox path"),
+    from: z12.string().optional().describe("Sender address"),
+    to: z12.string().optional().describe("Recipient address"),
+    cc: z12.string().optional().describe("CC recipient address"),
+    bcc: z12.string().optional().describe("BCC recipient address"),
+    subject: z12.string().optional().describe("Subject line"),
+    body: z12.string().optional().describe("Body text"),
+    text: z12.string().optional().describe("Full text (headers + body)"),
+    since: z12.string().optional().describe("Messages on or after this date (DD-Mon-YYYY or YYYY-MM-DD)"),
+    before: z12.string().optional().describe("Messages before this date"),
+    on: z12.string().optional().describe("Messages on this exact date"),
+    sentSince: z12.string().optional().describe("Sent on or after this date"),
+    sentBefore: z12.string().optional().describe("Sent before this date"),
+    sentOn: z12.string().optional().describe("Sent on this exact date"),
+    larger: z12.number().int().positive().optional().describe("Larger than N bytes"),
+    smaller: z12.number().int().positive().optional().describe("Smaller than N bytes"),
+    unseen: z12.boolean().optional().describe("Not read"),
+    seen: z12.boolean().optional().describe("Read"),
+    flagged: z12.boolean().optional().describe("Flagged"),
+    unflagged: z12.boolean().optional().describe("Not flagged"),
+    answered: z12.boolean().optional().describe("Answered"),
+    unanswered: z12.boolean().optional().describe("Not answered"),
+    deleted: z12.boolean().optional().describe("Deleted"),
+    undeleted: z12.boolean().optional().describe("Not deleted"),
+    keyword: z12.string().optional().describe("Has this keyword"),
+    unkeyword: z12.string().optional().describe("Does not have this keyword"),
+    new: z12.boolean().optional().describe("New (unseen + recent)"),
+    old: z12.boolean().optional().describe("Old (not recent)"),
+    recent: z12.boolean().optional().describe("Recent"),
+    account: z12.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const { mailbox: _mb, account: _acct, ...searchCriteria } = input;
+    const query = buildSearchQuery(
+      searchCriteria
+    );
+    const result = await client.search(query);
+    const uids = result ? [...result] : [];
+    return {
+      mailbox: input.mailbox,
+      uids,
+      count: uids.length
+    };
+  }
+});
+
+// src/tools/imap-read/status-mailbox.ts
+import { z as z13 } from "zod";
+var status_mailbox_default = defineTool({
+  name: "imap_status_mailbox",
+  description: "Counts (unread/total/recent) ohne SELECT (STATUS)",
+  category: "imap-read",
+  inputSchema: z13.object({
+    mailbox: z13.string().min(1).describe("Mailbox path (e.g. INBOX)"),
+    account: z13.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      const status = await client.status(input.mailbox, {
+        messages: true,
+        unseen: true,
+        recent: true,
+        uidNext: true,
+        uidValidity: true
+      });
+      return {
+        path: input.mailbox,
+        messages: status.messages ?? 0,
+        unseen: status.unseen ?? 0,
+        recent: status.recent ?? 0,
+        ...status.uidNext !== void 0 ? { uidNext: status.uidNext } : {},
+        ...status.uidValidity !== void 0 ? { uidValidity: status.uidValidity } : {}
+      };
+    } catch (err) {
+      throw new MailboxNotFoundError(input.mailbox);
+    }
+  }
+});
+
+// src/tools/imap-write/append-message.ts
+import { z as z14 } from "zod";
+var append_message_default = defineTool({
+  name: "imap_append_message",
+  description: "Mail in Folder schreiben (APPEND, Drafts/Import)",
+  category: "imap-write",
+  inputSchema: z14.object({
+    mailbox: z14.string().min(1).describe("Target mailbox path"),
+    raw: z14.string().min(1).describe("RFC-822 raw message content"),
+    flags: z14.array(z14.string()).optional().describe("Optional flags to set (e.g. ['\\Seen', '\\Drafts'])"),
+    date: z14.string().optional().describe("Optional internal date (ISO 8601 or imap date-time)"),
+    account: z14.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const normalizedFlags = input.flags?.map((f) => f.startsWith("\\") ? f : `\\${f}`);
+    const internalDate = input.date ? new Date(input.date) : void 0;
+    try {
+      const result = await client.append(input.mailbox, input.raw, normalizedFlags, internalDate);
+      const uid = result && result.uid !== void 0 ? Number(result.uid) : void 0;
+      return {
+        mailbox: input.mailbox,
+        ...uid !== void 0 ? { uid } : {}
+      };
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to append message: ${err}`);
+    }
+  }
+});
+
+// src/tools/imap-write/bulk-mark.ts
+import { z as z15 } from "zod";
+var bulk_mark_default = defineTool({
+  name: "imap_bulk_mark",
+  description: "Bulk-STORE \xFCber mehrere UIDs",
+  category: "imap-write",
+  inputSchema: z15.object({
+    mailbox: z15.string().min(1).describe("Mailbox path"),
+    uids: z15.array(z15.number().int().positive()).min(1).max(500).describe("Message UIDs"),
+    flags: z15.array(z15.string()).min(1).describe("Flags to set/add/remove"),
+    mode: z15.enum(["set", "add", "remove"]).default("set").describe("STORE mode"),
+    account: z15.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const normalizedFlags = input.flags.map(
+      (f) => f.startsWith("\\") ? f : `\\${f}`
+    );
+    const notFound = [];
+    let modified = 0;
+    for (const uid of input.uids) {
+      try {
+        switch (input.mode) {
+          case "set":
+            await client.messageFlagsSet(uid, normalizedFlags);
+            break;
+          case "add":
+            await client.messageFlagsAdd(uid, normalizedFlags);
+            break;
+          case "remove":
+            await client.messageFlagsRemove(uid, normalizedFlags);
+            break;
+        }
+        modified++;
+      } catch {
+        notFound.push(uid);
+      }
+    }
+    return {
+      modified,
+      uids: input.uids.filter((u) => !notFound.includes(u)),
+      notFound
+    };
+  }
+});
+
+// src/tools/imap-write/bulk-move.ts
+import { z as z16 } from "zod";
+var bulk_move_default = defineTool({
+  name: "imap_bulk_move",
+  description: "Bulk-MOVE \xFCber mehrere UIDs",
+  category: "imap-write",
+  inputSchema: z16.object({
+    fromMailbox: z16.string().min(1).describe("Source mailbox path"),
+    toMailbox: z16.string().min(1).describe("Target mailbox path"),
+    uids: z16.array(z16.number().int().positive()).min(1).max(500).describe("Message UIDs to move"),
+    account: z16.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.fromMailbox);
+    if (!mb) throw new MailboxNotFoundError(input.fromMailbox);
+    const moved = [];
+    const notFound = [];
+    try {
+      await client.messageMove(input.uids, input.toMailbox);
+      moved.push(...input.uids);
+    } catch {
+      for (const uid of input.uids) {
+        try {
+          await client.messageMove(uid, input.toMailbox);
+          moved.push(uid);
+        } catch {
+          try {
+            await client.messageCopy(uid, input.toMailbox);
+            await client.messageDelete(uid);
+            moved.push(uid);
+          } catch {
+            notFound.push(uid);
+          }
+        }
+      }
+    }
+    return {
+      fromMailbox: input.fromMailbox,
+      toMailbox: input.toMailbox,
+      moved: moved.length,
+      uids: moved,
+      notFound
+    };
+  }
+});
+
+// src/tools/imap-write/copy-message.ts
+import { z as z17 } from "zod";
+var copy_message_default = defineTool({
+  name: "imap_copy_message",
+  description: "Mail kopieren (COPY)",
+  category: "imap-write",
+  inputSchema: z17.object({
+    fromMailbox: z17.string().min(1).describe("Source mailbox path"),
+    toMailbox: z17.string().min(1).describe("Target mailbox path"),
+    uid: z17.number().int().positive().describe("Message UID"),
+    account: z17.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.fromMailbox);
+    if (!mb) throw new MailboxNotFoundError(input.fromMailbox);
+    let targetUid;
+    try {
+      const result = await client.messageCopy(input.uid, input.toMailbox);
+      if (result && result.uidMap) {
+        targetUid = result.uidMap.get(input.uid);
+      }
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to copy message: ${err}`);
+    }
+    return {
+      fromMailbox: input.fromMailbox,
+      toMailbox: input.toMailbox,
+      sourceUid: input.uid,
+      ...targetUid !== void 0 ? { targetUid } : {}
+    };
+  }
+});
+
+// src/tools/imap-write/delete-message.ts
+import { z as z18 } from "zod";
+var delete_message_default = defineTool({
+  name: "imap_delete_message",
+  description: "STORE \\Deleted + optional EXPUNGE",
+  category: "imap-write",
+  inputSchema: z18.object({
+    mailbox: z18.string().min(1).describe("Mailbox path"),
+    uid: z18.number().int().positive().describe("Message UID"),
+    expunge: z18.boolean().default(false).describe("Also EXPUNGE after marking (default: false)"),
+    account: z18.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    try {
+      await client.messageDelete(input.uid);
+    } catch (err) {
+      throw new UidNotFoundError(input.uid, input.mailbox);
+    }
+    let expunged = false;
+    if (input.expunge) {
+      try {
+        await client.mailboxClose();
+        expunged = true;
+      } catch (err) {
+        throw new ImapProtocolError(`Failed to expunge after delete: ${err}`);
+      }
+    }
+    return {
+      uid: input.uid,
+      mailbox: input.mailbox,
+      expunged
+    };
+  }
+});
+
+// src/tools/imap-write/expunge.ts
+import { z as z19 } from "zod";
+var expunge_default = defineTool({
+  name: "imap_expunge",
+  description: "EXPUNGE eines Folders",
+  category: "imap-write",
+  inputSchema: z19.object({
+    mailbox: z19.string().min(1).describe("Mailbox path to expunge"),
+    account: z19.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const beforeCount = mb.exists;
+    try {
+      await client.mailboxClose();
+      const after = await client.mailboxOpen(input.mailbox);
+      const afterCount = after?.exists ?? beforeCount;
+      return {
+        mailbox: input.mailbox,
+        expunged: Math.max(0, beforeCount - afterCount)
+      };
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to expunge mailbox: ${err}`);
+    }
+  }
+});
+
+// src/tools/imap-write/mark-message.ts
+import { z as z20 } from "zod";
+var mark_message_default = defineTool({
+  name: "imap_mark_message",
+  description: "Flags setzen/entfernen (STORE)",
+  category: "imap-write",
+  inputSchema: z20.object({
+    mailbox: z20.string().min(1).describe("Mailbox path"),
+    uid: z20.number().int().positive().describe("Message UID"),
+    flags: z20.array(z20.string()).min(1).describe("Flags to set/add/remove (e.g. ['\\Seen', '\\Flagged'])"),
+    mode: z20.enum(["set", "add", "remove"]).default("set").describe("STORE mode: set (replace), add (+FLAGS), remove (-FLAGS)"),
+    account: z20.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.mailbox);
+    if (!mb) throw new MailboxNotFoundError(input.mailbox);
+    const normalizedFlags = input.flags.map(
+      (f) => f.startsWith("\\") ? f : `\\${f}`
+    );
+    try {
+      switch (input.mode) {
+        case "set":
+          await client.messageFlagsSet(input.uid, normalizedFlags);
+          break;
+        case "add":
+          await client.messageFlagsAdd(input.uid, normalizedFlags);
+          break;
+        case "remove":
+          await client.messageFlagsRemove(input.uid, normalizedFlags);
+          break;
+      }
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to set flags: ${err}`);
+    }
+    return {
+      uid: input.uid,
+      flags: input.flags
+    };
+  }
+});
+
+// src/tools/imap-write/move-message.ts
+import { z as z21 } from "zod";
+var move_message_default = defineTool({
+  name: "imap_move_message",
+  description: "Mail verschieben (MOVE, Fallback COPY+EXPUNGE)",
+  category: "imap-write",
+  inputSchema: z21.object({
+    fromMailbox: z21.string().min(1).describe("Source mailbox path"),
+    toMailbox: z21.string().min(1).describe("Target mailbox path"),
+    uid: z21.number().int().positive().describe("Message UID"),
+    account: z21.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    const mb = await client.mailboxOpen(input.fromMailbox);
+    if (!mb) throw new MailboxNotFoundError(input.fromMailbox);
+    let targetUid;
+    try {
+      const result = await client.messageMove(input.uid, input.toMailbox);
+      if (result && result.uidMap) {
+        targetUid = result.uidMap.get(input.uid);
+      }
+    } catch (err) {
+      try {
+        const copyResult = await client.messageCopy(input.uid, input.toMailbox);
+        if (copyResult && copyResult.uidMap) {
+          targetUid = copyResult.uidMap.get(input.uid);
+        }
+        await client.messageDelete(input.uid);
+      } catch (fallbackErr) {
+        throw new ImapProtocolError(`Failed to move message: ${fallbackErr}`);
+      }
+    }
+    return {
+      fromMailbox: input.fromMailbox,
+      toMailbox: input.toMailbox,
+      sourceUid: input.uid,
+      ...targetUid !== void 0 ? { targetUid } : {}
+    };
+  }
+});
+
+// src/tools/imap-mailbox/create-mailbox.ts
+import { z as z22 } from "zod";
+var create_mailbox_default = defineTool({
+  name: "imap_create_mailbox",
+  description: "Neuen Folder anlegen (CREATE)",
+  category: "imap-mailbox",
+  inputSchema: z22.object({
+    path: z22.string().min(1).describe("Mailbox path to create"),
+    account: z22.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      await client.mailboxCreate(input.path);
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to create mailbox: ${err}`);
+    }
+    return { path: input.path, created: true };
+  }
+});
+
+// src/tools/imap-mailbox/delete-mailbox.ts
+import { z as z23 } from "zod";
+var delete_mailbox_default = defineTool({
+  name: "imap_delete_mailbox",
+  description: "Folder l\xF6schen (DELETE)",
+  category: "imap-mailbox",
+  inputSchema: z23.object({
+    path: z23.string().min(1).describe("Mailbox path to delete"),
+    account: z23.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      await client.mailboxDelete(input.path);
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to delete mailbox: ${err}`);
+    }
+    return { path: input.path, deleted: true };
+  }
+});
+
+// src/tools/imap-mailbox/rename-mailbox.ts
+import { z as z24 } from "zod";
+var rename_mailbox_default = defineTool({
+  name: "imap_rename_mailbox",
+  description: "Folder umbenennen (RENAME)",
+  category: "imap-mailbox",
+  inputSchema: z24.object({
+    from: z24.string().min(1).describe("Current mailbox path"),
+    to: z24.string().min(1).describe("New mailbox path"),
+    account: z24.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      await client.mailboxRename(input.from, input.to);
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to rename mailbox: ${err}`);
+    }
+    return { from: input.from, to: input.to, renamed: true };
+  }
+});
+
+// src/tools/imap-mailbox/subscribe-mailbox.ts
+import { z as z25 } from "zod";
+var subscribe_mailbox_default = defineTool({
+  name: "imap_subscribe_mailbox",
+  description: "Folder abonnieren (SUBSCRIBE)",
+  category: "imap-mailbox",
+  inputSchema: z25.object({
+    path: z25.string().min(1).describe("Mailbox path to subscribe"),
+    account: z25.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      await client.mailboxSubscribe(input.path);
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to subscribe to mailbox: ${err}`);
+    }
+    return { path: input.path, subscribed: true };
+  }
+});
+
+// src/tools/imap-mailbox/unsubscribe-mailbox.ts
+import { z as z26 } from "zod";
+var unsubscribe_mailbox_default = defineTool({
+  name: "imap_unsubscribe_mailbox",
+  description: "Folder-Abo entfernen (UNSUBSCRIBE)",
+  category: "imap-mailbox",
+  inputSchema: z26.object({
+    path: z26.string().min(1).describe("Mailbox path to unsubscribe"),
+    account: z26.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const client = await ctx.imap.acquire(accountName);
+    try {
+      await client.mailboxUnsubscribe(input.path);
+    } catch (err) {
+      throw new ImapProtocolError(`Failed to unsubscribe from mailbox: ${err}`);
+    }
+    return { path: input.path, subscribed: false };
+  }
+});
+
+// src/tools/smtp/forward.ts
+import { z as z27 } from "zod";
+
+// src/lib/sent-folder.ts
+var SENT_FALLBACKS = [
+  "Sent",
+  "Sent Items",
+  "[Gmail]/Sent Mail",
+  "[Gmail]/Gesendet",
+  "INBOX.Sent",
+  "Gesendet",
+  "Gesendete Elemente"
+];
+async function resolveSentFolder(client) {
+  const mailboxes = await client.list();
+  for (const mb of mailboxes) {
+    if (mb.specialUse === "\\Sent" || mb.specialUse === "Sent") {
+      return mb.path;
+    }
+    if (mb.flags.has("\\Sent")) {
+      return mb.path;
+    }
+  }
+  for (const name of SENT_FALLBACKS) {
+    try {
+      const status = await client.status(name, { messages: true });
+      if (status) return name;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/tools/smtp/forward.ts
+var forward_default = defineTool({
+  name: "smtp_forward",
+  description: "Weiterleiten (Original quoted oder als Attachment) + Sent-Ablage",
+  category: "smtp",
+  inputSchema: z27.object({
+    to: z27.union([z27.string(), z27.array(z27.object({ address: z27.string(), name: z27.string().optional() }))]).describe("Forward recipient(s)"),
+    cc: z27.union([z27.string(), z27.array(z27.object({ address: z27.string(), name: z27.string().optional() }))]).optional().describe("CC recipient(s)"),
+    bcc: z27.union([z27.string(), z27.array(z27.object({ address: z27.string(), name: z27.string().optional() }))]).optional().describe("BCC recipient(s)"),
+    subject: z27.string().optional().describe("Forward subject (default: Fwd: <original subject>)"),
+    text: z27.string().optional().describe("Additional plain text body"),
+    html: z27.string().optional().describe("Additional HTML body"),
+    originalMailbox: z27.string().min(1).describe("Mailbox containing the original message"),
+    originalUid: z27.number().int().positive().describe("UID of the original message"),
+    forwardAsAttachment: z27.boolean().default(false).describe("Forward as attachment (RFC-822) (default: false)"),
+    account: z27.string().optional().describe("Account name (default: default_account)"),
+    saveToSent: z27.boolean().default(true).describe("Save copy to Sent folder (default: true)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const transport = await ctx.smtp.acquire(accountName);
+    const accConfig = ctx.config.accounts.get(accountName);
+    const imapClient = await ctx.imap.acquire(accountName);
+    const mb = await imapClient.mailboxOpen(input.originalMailbox);
+    if (!mb) throw new MailboxNotFoundError(input.originalMailbox);
+    const original = await imapClient.fetchOne(input.originalUid, {
+      uid: true,
+      envelope: true,
+      source: true
+    });
+    if (!original) throw new UidNotFoundError(input.originalUid, input.originalMailbox);
+    const enc = original.envelope;
+    if (!enc) throw new Error("Original message has no envelope");
+    const subject = input.subject ?? (enc.subject?.startsWith("Fwd:") ? enc.subject : `Fwd: ${enc.subject ?? ""}`);
+    const mailOptions = {
+      from: accConfig.from_name ? `"${accConfig.from_name}" <${accConfig.user}>` : accConfig.user,
+      to: typeof input.to === "string" ? input.to : input.to.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", "),
+      cc: input.cc ? typeof input.cc === "string" ? input.cc : input.cc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ") : void 0,
+      bcc: input.bcc ? typeof input.bcc === "string" ? input.bcc : input.bcc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ") : void 0,
+      subject
+    };
+    if (input.forwardAsAttachment) {
+      const rawSource = original.source?.toString() ?? "";
+      mailOptions.attachments = [
+        {
+          filename: `forwarded-${input.originalUid}.eml`,
+          content: rawSource,
+          contentType: "message/rfc822"
+        }
+      ];
+      mailOptions.text = input.text ?? "";
+      mailOptions.html = input.html ?? "";
+    } else {
+      const fromStr = enc.from ? Array.isArray(enc.from) ? enc.from.map((f) => f.address ?? "").join(", ") : "" : "";
+      const toStr = enc.to ? Array.isArray(enc.to) ? enc.to.map((t) => t.address ?? "").join(", ") : "" : "";
+      const dateStr = enc.date ? enc.date.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      const quotedBody = original.source?.toString() ?? "";
+      const quotedText = input.text ? `${input.text}
+
+-------- Forwarded Message --------
+Subject: ${enc.subject ?? ""}
+Date: ${dateStr}
+From: ${fromStr}
+To: ${toStr}
+
+${quotedBody}` : `-------- Forwarded Message --------
+Subject: ${enc.subject ?? ""}
+Date: ${dateStr}
+From: ${fromStr}
+To: ${toStr}
+
+${quotedBody}`;
+      mailOptions.text = quotedText;
+    }
+    let info;
+    try {
+      info = await transport.sendMail(mailOptions);
+    } catch (err) {
+      throw new SmtpRelayError(`Failed to forward email: ${err}`);
+    }
+    let savedToSent = false;
+    let sentMailbox;
+    let sentSaveError;
+    if (input.saveToSent) {
+      try {
+        const sentFolder = await resolveSentFolder(imapClient);
+        if (sentFolder) {
+          sentMailbox = sentFolder;
+          const rawLines = [];
+          rawLines.push(`From: ${mailOptions.from}`);
+          rawLines.push(`To: ${mailOptions.to}`);
+          if (mailOptions.cc) rawLines.push(`Cc: ${mailOptions.cc}`);
+          rawLines.push(`Subject: ${subject}`);
+          rawLines.push(`Date: ${(/* @__PURE__ */ new Date()).toUTCString()}`);
+          rawLines.push("MIME-Version: 1.0");
+          rawLines.push("Content-Type: text/plain; charset=UTF-8");
+          rawLines.push("");
+          rawLines.push(mailOptions.text ?? "");
+          await imapClient.append(sentFolder, rawLines.join("\r\n"));
+          savedToSent = true;
+        } else {
+          sentSaveError = "No Sent folder found";
+        }
+      } catch (err) {
+        sentSaveError = `Failed to save to Sent: ${err}`;
+      }
+    }
+    return {
+      messageId: info.messageId ?? "",
+      accepted: info.accepted ?? [],
+      rejected: info.rejected ?? [],
+      response: info.response ?? "",
+      savedToSent,
+      ...sentMailbox ? { sentMailbox } : {},
+      ...sentSaveError ? { sentSaveError } : {}
+    };
+  }
+});
+
+// src/tools/smtp/reply.ts
+import { z as z28 } from "zod";
+var reply_default = defineTool({
+  name: "smtp_reply",
+  description: "Antwort mit korrekter In-Reply-To/References-Kette + Sent-Ablage",
+  category: "smtp",
+  inputSchema: z28.object({
+    to: z28.union([z28.string(), z28.array(z28.object({ address: z28.string(), name: z28.string().optional() }))]).optional().describe("Reply recipient(s) (default: from of original)"),
+    cc: z28.union([z28.string(), z28.array(z28.object({ address: z28.string(), name: z28.string().optional() }))]).optional().describe("CC recipient(s)"),
+    subject: z28.string().optional().describe("Reply subject (default: Re: <original subject>)"),
+    text: z28.string().optional().describe("Plain text body"),
+    html: z28.string().optional().describe("HTML body"),
+    originalMailbox: z28.string().min(1).describe("Mailbox containing the original message"),
+    originalUid: z28.number().int().positive().describe("UID of the original message"),
+    replyAll: z28.boolean().default(false).describe("Reply to all recipients (default: false)"),
+    account: z28.string().optional().describe("Account name (default: default_account)"),
+    saveToSent: z28.boolean().default(true).describe("Save copy to Sent folder (default: true)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const transport = await ctx.smtp.acquire(accountName);
+    const accConfig = ctx.config.accounts.get(accountName);
+    const imapClient = await ctx.imap.acquire(accountName);
+    const mb = await imapClient.mailboxOpen(input.originalMailbox);
+    if (!mb) throw new MailboxNotFoundError(input.originalMailbox);
+    const original = await imapClient.fetchOne(input.originalUid, {
+      uid: true,
+      envelope: true,
+      headers: true
+    });
+    if (!original) throw new UidNotFoundError(input.originalUid, input.originalMailbox);
+    const enc = original.envelope;
+    if (!enc) throw new Error("Original message has no envelope");
+    const messageId = enc.messageId ?? "";
+    const rawHeaders = original.headers?.toString() ?? "";
+    const refMatch = rawHeaders.match(/^references:\s*(.*)$/im);
+    const existingRefs = refMatch ? refMatch[1]?.trim().split(/\s+/) ?? [] : [];
+    const references = [...existingRefs, messageId].filter(Boolean);
+    const inReplyTo = messageId;
+    let to = input.to;
+    const cc = input.cc;
+    if (!to) {
+      const fromAddr = enc.from?.[0];
+      to = fromAddr?.address ?? "";
+    }
+    if (input.replyAll && enc.to) {
+    }
+    const subject = input.subject ?? (enc.subject?.startsWith("Re:") ? enc.subject : `Re: ${enc.subject ?? ""}`);
+    const mailOptions = {
+      from: accConfig.from_name ? `"${accConfig.from_name}" <${accConfig.user}>` : accConfig.user,
+      to: typeof to === "string" ? to : Array.isArray(to) ? to.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ") : void 0,
+      cc: typeof cc === "string" ? cc : Array.isArray(cc) ? cc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ") : void 0,
+      subject,
+      text: input.text,
+      html: input.html,
+      inReplyTo,
+      references: references.join(" ")
+    };
+    let info;
+    try {
+      info = await transport.sendMail(mailOptions);
+    } catch (err) {
+      throw new SmtpRelayError(`Failed to send reply: ${err}`);
+    }
+    let savedToSent = false;
+    let sentMailbox;
+    let sentSaveError;
+    if (input.saveToSent) {
+      try {
+        const sentFolder = await resolveSentFolder(imapClient);
+        if (sentFolder) {
+          sentMailbox = sentFolder;
+          const rawLines = [];
+          rawLines.push(`From: ${mailOptions.from}`);
+          rawLines.push(`To: ${mailOptions.to}`);
+          if (mailOptions.cc) rawLines.push(`Cc: ${mailOptions.cc}`);
+          rawLines.push(`Subject: ${subject}`);
+          rawLines.push(`In-Reply-To: ${inReplyTo}`);
+          rawLines.push(`References: ${references.join(" ")}`);
+          rawLines.push(`Date: ${(/* @__PURE__ */ new Date()).toUTCString()}`);
+          rawLines.push("MIME-Version: 1.0");
+          rawLines.push("Content-Type: text/plain; charset=UTF-8");
+          rawLines.push("");
+          rawLines.push(input.text ?? input.html ?? "");
+          await imapClient.append(sentFolder, rawLines.join("\r\n"));
+          savedToSent = true;
+        } else {
+          sentSaveError = "No Sent folder found";
+        }
+      } catch (err) {
+        sentSaveError = `Failed to save to Sent: ${err}`;
+      }
+    }
+    return {
+      messageId: info.messageId ?? "",
+      inReplyTo,
+      accepted: info.accepted ?? [],
+      rejected: info.rejected ?? [],
+      response: info.response ?? "",
+      savedToSent,
+      ...sentMailbox ? { sentMailbox } : {},
+      ...sentSaveError ? { sentSaveError } : {}
+    };
+  }
+});
+
+// src/tools/smtp/send-raw.ts
+import { z as z29 } from "zod";
+var send_raw_default = defineTool({
+  name: "smtp_send_raw",
+  description: "Vor-formatierte RFC-822 senden (Power-User) + Sent-Ablage",
+  category: "smtp",
+  inputSchema: z29.object({
+    raw: z29.string().min(1).describe("Raw RFC-822 message content to send"),
+    account: z29.string().optional().describe("Account name (default: default_account)"),
+    saveToSent: z29.boolean().default(true).describe("Save copy to Sent folder (default: true)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const transport = await ctx.smtp.acquire(accountName);
+    const mailOptions = {
+      raw: input.raw
+    };
+    let info;
+    try {
+      info = await transport.sendMail(mailOptions);
+    } catch (err) {
+      throw new SmtpRelayError(`Failed to send raw email: ${err}`);
+    }
+    let savedToSent = false;
+    let sentMailbox;
+    let sentSaveError;
+    if (input.saveToSent) {
+      try {
+        const imapClient = await ctx.imap.acquire(accountName);
+        const sentFolder = await resolveSentFolder(imapClient);
+        if (sentFolder) {
+          sentMailbox = sentFolder;
+          await imapClient.append(sentFolder, input.raw);
+          savedToSent = true;
+        } else {
+          sentSaveError = "No Sent folder found";
+        }
+      } catch (err) {
+        sentSaveError = `Failed to save to Sent: ${err}`;
+      }
+    }
+    return {
+      messageId: info.messageId ?? "",
+      accepted: info.accepted ?? [],
+      rejected: info.rejected ?? [],
+      response: info.response ?? "",
+      savedToSent,
+      ...sentMailbox ? { sentMailbox } : {},
+      ...sentSaveError ? { sentSaveError } : {}
+    };
+  }
+});
+
+// src/tools/smtp/send.ts
+import { z as z30 } from "zod";
+function buildAddresses(list) {
+  if (!list) return void 0;
+  if (typeof list === "string") return list;
+  return list.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address);
+}
+var send_default = defineTool({
+  name: "smtp_send",
+  description: "Mail senden + optionale Sent-Ablage",
+  category: "smtp",
+  inputSchema: z30.object({
+    to: z30.union([z30.string(), z30.array(z30.object({ address: z30.string(), name: z30.string().optional() }))]).describe("Recipient(s)"),
+    cc: z30.union([z30.string(), z30.array(z30.object({ address: z30.string(), name: z30.string().optional() }))]).optional().describe("CC recipient(s)"),
+    bcc: z30.union([z30.string(), z30.array(z30.object({ address: z30.string(), name: z30.string().optional() }))]).optional().describe("BCC recipient(s)"),
+    subject: z30.string().min(1).describe("Email subject"),
+    text: z30.string().optional().describe("Plain text body"),
+    html: z30.string().optional().describe("HTML body"),
+    attachments: z30.array(
+      z30.object({
+        filename: z30.string().optional(),
+        content: z30.string().optional(),
+        path: z30.string().optional(),
+        contentType: z30.string().optional(),
+        cid: z30.string().optional()
+      })
+    ).optional().describe("Attachments"),
+    account: z30.string().optional().describe("Account name (default: default_account)"),
+    saveToSent: z30.boolean().default(true).describe("Save copy to Sent folder (default: true)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const transport = await ctx.smtp.acquire(accountName);
+    const accConfig = ctx.config.accounts.get(accountName);
+    const mailOptions = {
+      from: accConfig.from_name ? `"${accConfig.from_name}" <${accConfig.user}>` : accConfig.user,
+      to: buildAddresses(input.to),
+      cc: buildAddresses(
+        input.cc
+      ),
+      bcc: buildAddresses(
+        input.bcc
+      ),
+      subject: input.subject,
+      text: input.text,
+      html: input.html,
+      attachments: input.attachments
+    };
+    let info;
+    try {
+      info = await transport.sendMail(mailOptions);
+    } catch (err) {
+      throw new SmtpRelayError(`Failed to send email: ${err}`);
+    }
+    let savedToSent = false;
+    let sentMailbox;
+    let sentSaveError;
+    if (input.saveToSent) {
+      try {
+        const imapClient = await ctx.imap.acquire(accountName);
+        const sentFolder = await resolveSentFolder(imapClient);
+        if (sentFolder) {
+          sentMailbox = sentFolder;
+          const raw = await buildRfc822(
+            {
+              user: accConfig.user,
+              ...accConfig.from_name ? { from_name: accConfig.from_name } : {}
+            },
+            mailOptions
+          );
+          await imapClient.append(sentFolder, raw);
+          savedToSent = true;
+        } else {
+          sentSaveError = "No Sent folder found";
+        }
+      } catch (err) {
+        sentSaveError = `Failed to save to Sent: ${err}`;
+      }
+    }
+    return {
+      messageId: info.messageId ?? "",
+      accepted: info.accepted ?? [],
+      rejected: info.rejected ?? [],
+      response: info.response ?? "",
+      savedToSent,
+      ...sentMailbox ? { sentMailbox } : {},
+      ...sentSaveError ? { sentSaveError } : {}
+    };
+  }
+});
+async function buildRfc822(acc, opts) {
+  const lines = [];
+  const from = typeof opts.from === "string" ? opts.from : acc.from_name ? `"${acc.from_name}" <${acc.user}>` : acc.user;
+  const to = typeof opts.to === "string" ? opts.to : Array.isArray(opts.to) ? opts.to.join(", ") : "";
+  const date = (/* @__PURE__ */ new Date()).toUTCString();
+  lines.push(`From: ${from}`);
+  lines.push(`To: ${to}`);
+  if (opts.cc) {
+    const ccStr = typeof opts.cc === "string" ? opts.cc : opts.cc.map((a) => a.address).join(", ");
+    lines.push(`Cc: ${ccStr}`);
+  }
+  lines.push(`Subject: ${opts.subject ?? ""}`);
+  lines.push(`Date: ${date}`);
+  lines.push("MIME-Version: 1.0");
+  lines.push("Content-Type: text/plain; charset=UTF-8");
+  lines.push("Content-Transfer-Encoding: 7bit");
+  lines.push("");
+  lines.push(opts.text ? opts.text : opts.html ? opts.html : "");
+  return lines.join("\r\n");
+}
+
+// src/tools/smtp/verify-connection.ts
+import { z as z31 } from "zod";
+var verify_connection_default = defineTool({
+  name: "smtp_verify_connection",
+  description: "SMTP-Connection-Health-Check (EHLO, AUTH)",
+  category: "smtp",
+  inputSchema: z31.object({
+    account: z31.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const transport = await ctx.smtp.acquire(accountName);
+    const accConfig = ctx.config.accounts.get(accountName);
+    const start = Date.now();
+    try {
+      const ok = await transport.verify();
+      const latencyMs = Date.now() - start;
+      return {
+        ok,
+        host: accConfig.smtp_host ?? "unknown",
+        port: accConfig.smtp_port,
+        tls: accConfig.smtp_tls === "implicit" ? "implicit" : accConfig.smtp_tls === "starttls" ? "starttls" : "none",
+        latencyMs
+      };
+    } catch (err) {
+      const error = err;
+      if (error.message?.includes("auth") || error.message?.includes("login")) {
+        throw new AuthError(`SMTP authentication failed: ${error.message}`);
+      }
+      throw new SmtpRelayError(`SMTP connection failed: ${error.message}`);
+    }
+  }
+});
+
+// src/tools/account/add.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { parse as parseToml2, stringify as stringifyToml } from "smol-toml";
+import { z as z32 } from "zod";
+var add_default = defineTool({
+  name: "account_add",
+  description: "Neuen Account zur Config hinzuf\xFCgen",
+  category: "account",
+  inputSchema: z32.object({
+    name: z32.string().min(1).describe("Account name"),
+    user: z32.string().min(1).describe("Email address / IMAP login"),
+    pass: z32.string().min(1).describe("Password or app password"),
+    imap_host: z32.string().optional().describe("IMAP host (auto-detect if omitted)"),
+    imap_port: z32.number().int().positive().optional().describe("IMAP port (default: 993)"),
+    imap_tls: z32.enum(["implicit", "starttls", "none"]).optional().describe("IMAP TLS mode"),
+    smtp_host: z32.string().optional().describe("SMTP host (auto-detect if omitted)"),
+    smtp_port: z32.number().int().positive().optional().describe("SMTP port (default: 465)"),
+    smtp_tls: z32.enum(["implicit", "starttls", "none"]).optional().describe("SMTP TLS mode"),
+    from_name: z32.string().optional().describe("Display name for sent emails"),
+    verify_tls: z32.boolean().optional().describe("Verify TLS certificate (default: true)")
+  }),
+  handler: async (input, ctx) => {
+    if (ctx.config.mode !== "config-file" || !ctx.config.configPath) {
+      throw new ConfigError(
+        "Account mutations require a config file (multi-account mode). Use --config=<path> or set up a config file."
+      );
+    }
+    const configPath = ctx.config.configPath;
+    let raw;
+    try {
+      raw = readFileSync2(configPath, "utf8");
+    } catch {
+      throw new ConfigError(`Cannot read config file: ${configPath}`);
+    }
+    const parsed = parseToml2(raw);
+    const accounts = parsed.accounts ?? [];
+    if (accounts.some((a) => a.name === input.name)) {
+      throw new ConfigError(`Account "${input.name}" already exists`);
+    }
+    const newAccount = {
+      name: input.name,
+      user: input.user,
+      pass: input.pass
+    };
+    if (input.imap_host) newAccount.imap_host = input.imap_host;
+    if (input.imap_port) newAccount.imap_port = input.imap_port;
+    if (input.imap_tls) newAccount.imap_tls = input.imap_tls;
+    if (input.smtp_host) newAccount.smtp_host = input.smtp_host;
+    if (input.smtp_port) newAccount.smtp_port = input.smtp_port;
+    if (input.smtp_tls) newAccount.smtp_tls = input.smtp_tls;
+    if (input.from_name) newAccount.from_name = input.from_name;
+    if (input.verify_tls !== void 0) newAccount.verify_tls = input.verify_tls;
+    accounts.push(newAccount);
+    parsed.accounts = accounts;
+    const tomlStr = stringifyToml(parsed);
+    writeFileSync2(configPath, tomlStr, "utf8");
+    ctx.logger.info({ account: input.name }, "Account added to config file");
+    return { name: input.name, created: true, configPath };
+  }
+});
+
+// src/tools/account/delete.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { parse as parseToml3, stringify as stringifyToml2 } from "smol-toml";
+import { z as z33 } from "zod";
+var delete_default = defineTool({
+  name: "account_delete",
+  description: "Account aus Config entfernen",
+  category: "account",
+  inputSchema: z33.object({
+    name: z33.string().min(1).describe("Account name to delete")
+  }),
+  handler: async (input, ctx) => {
+    if (ctx.config.mode !== "config-file" || !ctx.config.configPath) {
+      throw new ConfigError("Account mutations require a config file (multi-account mode).");
+    }
+    const configPath = ctx.config.configPath;
+    let raw;
+    try {
+      raw = readFileSync3(configPath, "utf8");
+    } catch {
+      throw new ConfigError(`Cannot read config file: ${configPath}`);
+    }
+    const parsed = parseToml3(raw);
+    const accounts = parsed.accounts ?? [];
+    const idx = accounts.findIndex((a) => a.name === input.name);
+    if (idx === -1) {
+      throw new AccountNotFoundError(input.name);
+    }
+    accounts.splice(idx, 1);
+    parsed.accounts = accounts;
+    if (parsed.default_account === input.name) {
+      if (accounts.length > 0) {
+        parsed.default_account = accounts[0]?.name;
+      } else {
+        parsed.default_account = void 0;
+      }
+    }
+    const tomlStr = stringifyToml2(parsed);
+    writeFileSync3(configPath, tomlStr, "utf8");
+    ctx.logger.info({ account: input.name }, "Account deleted");
+    return { name: input.name, deleted: true };
+  }
+});
+
+// src/tools/account/list.ts
+import { z as z34 } from "zod";
+var list_default = defineTool({
+  name: "account_list",
+  description: "Konfigurierte Accounts auflisten (Credentials masked)",
+  category: "account",
+  inputSchema: z34.object({}),
+  handler: async (_input, ctx) => {
+    const accounts = [...ctx.config.accounts.entries()].map(([name, acc]) => ({
+      name,
+      user: acc.user,
+      imapHost: acc.imap_host ?? "auto-detect",
+      smtpHost: acc.smtp_host ?? "auto-detect"
+    }));
+    return {
+      defaultAccount: ctx.config.defaultAccount,
+      accounts,
+      mode: ctx.config.mode
+    };
+  }
+});
+
+// src/tools/account/update.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { parse as parseToml4, stringify as stringifyToml3 } from "smol-toml";
+import { z as z35 } from "zod";
+var update_default = defineTool({
+  name: "account_update",
+  description: "Bestehenden Account modifizieren",
+  category: "account",
+  inputSchema: z35.object({
+    name: z35.string().min(1).describe("Account name to modify"),
+    user: z35.string().optional().describe("New email address / IMAP login"),
+    pass: z35.string().optional().describe("New password or app password"),
+    imap_host: z35.string().optional().describe("New IMAP host"),
+    imap_port: z35.number().int().positive().optional().describe("New IMAP port"),
+    imap_tls: z35.enum(["implicit", "starttls", "none"]).optional().describe("New IMAP TLS mode"),
+    smtp_host: z35.string().optional().describe("New SMTP host"),
+    smtp_port: z35.number().int().positive().optional().describe("New SMTP port"),
+    smtp_tls: z35.enum(["implicit", "starttls", "none"]).optional().describe("New SMTP TLS mode"),
+    from_name: z35.string().optional().describe("New display name"),
+    verify_tls: z35.boolean().optional().describe("New TLS verification setting")
+  }),
+  handler: async (input, ctx) => {
+    if (ctx.config.mode !== "config-file" || !ctx.config.configPath) {
+      throw new ConfigError("Account mutations require a config file (multi-account mode).");
+    }
+    const configPath = ctx.config.configPath;
+    let raw;
+    try {
+      raw = readFileSync4(configPath, "utf8");
+    } catch {
+      throw new ConfigError(`Cannot read config file: ${configPath}`);
+    }
+    const parsed = parseToml4(raw);
+    const accounts = parsed.accounts ?? [];
+    const account = accounts.find((a) => a.name === input.name);
+    if (!account) {
+      throw new AccountNotFoundError(input.name);
+    }
+    const changedFields = [];
+    const updatable = [
+      ["user", input.user],
+      ["pass", input.pass],
+      ["imap_host", input.imap_host],
+      ["imap_port", input.imap_port],
+      ["imap_tls", input.imap_tls],
+      ["smtp_host", input.smtp_host],
+      ["smtp_port", input.smtp_port],
+      ["smtp_tls", input.smtp_tls],
+      ["from_name", input.from_name]
+    ];
+    for (const [key, value] of updatable) {
+      if (value !== void 0) {
+        account[key] = value;
+        changedFields.push(key);
+      }
+    }
+    if (input.verify_tls !== void 0) {
+      account.verify_tls = input.verify_tls;
+      changedFields.push("verify_tls");
+    }
+    if (changedFields.length === 0) {
+      throw new ConfigError("No fields to update");
+    }
+    parsed.accounts = accounts;
+    const tomlStr = stringifyToml3(parsed);
+    writeFileSync4(configPath, tomlStr, "utf8");
+    ctx.logger.info({ account: input.name, changedFields }, "Account updated");
+    return { name: input.name, updated: true, changedFields };
+  }
+});
+
+// src/tools/meta/health.ts
+import { z as z36 } from "zod";
+var health_default = defineTool({
+  name: "meta_health",
+  description: "IMAP + SMTP Erreichbarkeit, Latenz, Capabilities",
+  category: "meta",
+  inputSchema: z36.object({
+    account: z36.string().optional().describe("Account name (default: default_account)")
+  }),
+  handler: async (input, ctx) => {
+    const accountName = ctx.resolveAccount(input.account);
+    const accConfig = ctx.config.accounts.get(accountName);
+    let imapOk = false;
+    let imapLatencyMs;
+    let imapCaps;
+    let imapError;
+    try {
+      const imapStart = Date.now();
+      const client = await ctx.imap.acquire(accountName);
+      const caps = [...client.capabilities.keys()];
+      imapLatencyMs = Date.now() - imapStart;
+      imapOk = true;
+      imapCaps = caps;
+    } catch (err) {
+      imapError = String(err);
+    }
+    let smtpOk = false;
+    let smtpLatencyMs;
+    let smtpError;
+    try {
+      const smtpStart = Date.now();
+      const transport = await ctx.smtp.acquire(accountName);
+      const verify = await transport.verify();
+      smtpLatencyMs = Date.now() - smtpStart;
+      smtpOk = verify;
+    } catch (err) {
+      smtpError = String(err);
+    }
+    return {
+      account: accountName,
+      imap: {
+        ok: imapOk,
+        ...imapLatencyMs !== void 0 ? { latencyMs: imapLatencyMs } : {},
+        ...imapCaps ? { capabilities: imapCaps } : {},
+        ...imapError ? { error: imapError } : {}
+      },
+      smtp: {
+        ok: smtpOk,
+        ...smtpLatencyMs !== void 0 ? { latencyMs: smtpLatencyMs } : {},
+        ...smtpError ? { error: smtpError } : {}
+      }
+    };
+  }
+});
+
+// src/tools/meta/server-info.ts
+import { z as z37 } from "zod";
+var server_info_default = defineTool({
+  name: "meta_server_info",
+  description: "Aktive Tools, aktiver Modus, Version",
+  category: "meta",
+  inputSchema: z37.object({}),
+  handler: async (_input, ctx) => {
+    const flags = {
+      safe: ctx.flags.safe,
+      readonly: ctx.flags.readonly,
+      noImap: ctx.flags.noImap,
+      noSmtp: ctx.flags.noSmtp
+    };
+    if (ctx.flags.allowTools?.length) flags.allowTools = ctx.flags.allowTools;
+    if (ctx.flags.denyTools?.length) flags.denyTools = ctx.flags.denyTools;
+    return {
+      name: SERVER_NAME,
+      version: SERVER_VERSION,
+      activeTools: ctx.activeTools,
+      flags
+    };
+  }
+});
+
+// src/tools/index.ts
+var ALL_TOOLS = [
+  list_mailboxes_default,
+  status_mailbox_default,
+  list_messages_default,
+  get_message_default,
+  get_message_headers_default,
+  get_message_raw_default,
+  get_messages_bulk_default,
+  search_default,
+  download_attachment_default,
+  get_thread_default,
+  get_quota_default,
+  check_capabilities_default,
+  mark_message_default,
+  bulk_mark_default,
+  move_message_default,
+  copy_message_default,
+  bulk_move_default,
+  append_message_default,
+  expunge_default,
+  delete_message_default,
+  create_mailbox_default,
+  delete_mailbox_default,
+  rename_mailbox_default,
+  subscribe_mailbox_default,
+  unsubscribe_mailbox_default,
+  send_default,
+  reply_default,
+  forward_default,
+  verify_connection_default,
+  send_raw_default,
+  list_default,
+  add_default,
+  update_default,
+  delete_default,
+  health_default,
+  server_info_default
+];
+
+// src/server/server.ts
+var SERVER_NAME = "classic-imap-smtp-mcp";
+var SERVER_VERSION = "0.3.0";
+function buildServer(opts, ctx, logger) {
+  const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
+  const active = resolveActiveTools(ALL_TOOLS, opts);
+  logger.info({ count: active.length, tools: active.map((t) => t.name) }, "Registering tools");
+  for (const tool of active) {
+    server.registerTool(
+      tool.name,
+      { description: tool.description, inputSchema: tool.inputSchema },
+      async (input) => {
+        try {
+          const result = await tool.handler(input, ctx);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (err) {
+          const payload = err instanceof McpMailError ? err.toResult() : { code: "INTERNAL_ERROR", message: String(err) };
+          logger.error({ tool: tool.name, err: payload }, "Tool call failed");
+          return {
+            isError: true,
+            content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+          };
+        }
+      }
+    );
+  }
+  return server;
+}
+async function runStdio(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/bin/main.ts
+var HELP = `classic-imap-smtp-mcp \u2014 classic IMAP/SMTP MCP server (stdio)
+
+Usage: classic-imap-smtp-mcp [options]
+
+Options:
+  --safe               Disable delete tools (delete/expunge/delete-mailbox)
+  --readonly           Read-only: no writes, no SMTP send
+  --no-imap            Disable all IMAP tools
+  --no-smtp            Disable all SMTP tools
+  --allow-tools=<csv>  Explicitly enable tools (overrides feature flags, prefix wildcards)
+  --deny-tools=<csv>   Explicitly remove tools (wins over everything, prefix wildcards)
+  --account=<name>     Default account override
+  --config=<path>      Alternative config path
+  --log-level=<level>  trace|debug|info|warn|error (default: info)
+  --log-format=<fmt>   json|pretty (default: json)
+  -h, --help           Show help
+  -V, --version        Show version
+
+Subcommands:
+  init                 Write a template config to the XDG path
+  test [account]       Test IMAP+SMTP connection
+  list-tools           Dry-run: which tools would register with the current flags
+`;
+var TEMPLATE_CONFIG = `# classic-imap-smtp-mcp \u2014 Multi-Account Config
+# Generated by \`classic-imap-smtp-mcp init\`
+# Pfad: see defaultConfigPath()
+# Datei sollte Permission 0600 haben \u2014 der Server warnt sonst.
+
+default_account = "personal"
+
+# Optional: globale Rate-Limits
+[limits]
+smtp_per_minute = 10
+imap_ops_per_second = 100
+
+# --- F\xFCge hier deine Accounts ein ---
+# Beispiel mit Provider-Auto-Detect (nur user/pass n\xF6tig):
+[[accounts]]
+name = "personal"
+user = "you@gmail.com"
+pass = "your-app-password"
+from_name = "Your Name"
+
+# Beispiel mit explizitem Host/Port:
+# [[accounts]]
+# name = "work"
+# user = "you@company.com"
+# pass = "another-app-password"
+# imap_host = "imap.company.com"
+# imap_port = 993
+# imap_tls = "implicit"
+# smtp_host = "smtp.company.com"
+# smtp_port = 587
+# smtp_tls = "starttls"
+# from_name = "You at Work"
+`;
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (parsed.version) {
+    process.stdout.write(`${SERVER_VERSION}
+`);
+    return;
+  }
+  const logger = createLogger({ level: parsed.options.logLevel, format: parsed.options.logFormat });
+  if (parsed.options.noImap && parsed.options.noSmtp) {
+    logger.error("Both --no-imap and --no-smtp set: server would expose no mail tools. Aborting.");
+    process.exit(1);
+  }
+  if (parsed.subcommand === "init") {
+    await handleInit(logger);
+    return;
+  }
+  if (parsed.subcommand === "list-tools") {
+    await handleListTools(parsed.options, logger);
+    return;
+  }
+  if (parsed.subcommand === "test") {
+    await handleTest(parsed.options, parsed.subcommandArg, logger);
+    return;
+  }
+  const config = loadConfig(parsed.options.configPath);
+  const imap = new ImapPool(config, logger);
+  const smtp = new SmtpPool(config, logger);
+  const activeTools = resolveActiveTools(ALL_TOOLS, parsed.options).map((t) => t.name);
+  const ctx = {
+    config,
+    imap,
+    smtp,
+    logger,
+    activeTools,
+    flags: parsed.options,
+    resolveAccount(name) {
+      const target = name ?? parsed.options.account ?? config.defaultAccount;
+      if (!config.accounts.has(target)) throw new AccountNotFoundError(target);
+      return target;
+    }
+  };
+  const server = buildServer(parsed.options, ctx, logger);
+  const shutdown = async () => {
+    await Promise.allSettled([imap.closeAll(), smtp.closeAll()]);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await runStdio(server);
+  logger.info("classic-imap-smtp-mcp running on stdio");
+}
+async function handleInit(logger) {
+  const configPath = defaultConfigPath();
+  const dir = dirname(configPath);
+  if (!existsSync(configPath)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync5(configPath, TEMPLATE_CONFIG, "utf8");
+    try {
+      if (process.platform !== "win32") {
+        const { chmodSync } = await import("fs");
+        chmodSync(configPath, 384);
+      }
+    } catch {
+    }
+    process.stdout.write(`Template config written to: ${configPath}
+`);
+    process.stdout.write("Edit the file with your account details, then run the server.\n");
+  } else {
+    process.stdout.write(`Config file already exists: ${configPath}
+`);
+  }
+}
+async function handleListTools(options, logger) {
+  const active = resolveActiveTools(ALL_TOOLS, options);
+  const lines = [];
+  lines.push(`Active tools: ${active.length}/${ALL_TOOLS.length}`);
+  for (const t of active) {
+    lines.push(`  ${t.name.padEnd(32)} ${t.category}`);
+  }
+  const denied = ALL_TOOLS.length - active.length;
+  if (denied > 0) {
+    lines.push(`
+Blocked by flags: ${denied} tool(s)`);
+    const blocked = ALL_TOOLS.filter((t) => !active.find((a) => a.name === t.name));
+    for (const t of blocked) {
+      lines.push(`  ${t.name.padEnd(32)} ${t.category}`);
+    }
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+async function handleTest(options, accountArg, logger) {
+  const config = loadConfig(options.configPath);
+  const imap = new ImapPool(config, logger);
+  const smtp = new SmtpPool(config, logger);
+  const accountName = accountArg ?? config.defaultAccount;
+  if (!config.accounts.has(accountName)) {
+    process.stderr.write(`Account not found: ${accountName}
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`Testing account: ${accountName}
+`);
+  process.stdout.write("  IMAP... ");
+  try {
+    const start = Date.now();
+    const client = await imap.acquire(accountName);
+    const caps = [...client.capabilities.keys()];
+    const latency = Date.now() - start;
+    process.stdout.write(`OK (${latency}ms, ${caps.length} capabilities)
+`);
+  } catch (err) {
+    process.stdout.write(`FAIL: ${err}
+`);
+  }
+  process.stdout.write("  SMTP... ");
+  try {
+    const start = Date.now();
+    const transport = await smtp.acquire(accountName);
+    await transport.verify();
+    const latency = Date.now() - start;
+    process.stdout.write(`OK (${latency}ms)
+`);
+  } catch (err) {
+    process.stdout.write(`FAIL: ${err}
+`);
+  }
+  await imap.closeAll();
+  await smtp.closeAll();
+}
+main().catch((err) => {
+  const msg = err instanceof McpMailError ? `${err.code}: ${err.message}` : String(err);
+  process.stderr.write(`Fatal: ${msg}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=main.js.map