@lengelhard/imap-email-mcp 1.0.1

package/.env.example

@@ -0,0 +1,40 @@
+# IMAP Email MCP Server Configuration
+# Copy this file to .env and fill in your values
+
+# Required - IMAP Settings
+IMAP_USER=your-email@example.com
+IMAP_PASSWORD=your-app-password
+IMAP_HOST=imap.example.com
+
+# Optional - IMAP Settings (defaults shown)
+# IMAP_PORT=993
+# IMAP_TLS=true
+# IMAP_AUTH_TIMEOUT=10000
+# IMAP_TLS_REJECT_UNAUTHORIZED=true
+
+# Optional - SMTP Settings (defaults to IMAP values if not set)
+# SMTP_HOST=smtp.example.com
+# SMTP_PORT=465
+# SMTP_SECURE=true
+# SMTP_USER=your-email@example.com
+# SMTP_PASSWORD=your-app-password
+
+# Common Provider Settings:
+#
+# Gmail:
+#   IMAP_HOST=imap.gmail.com
+#   SMTP_HOST=smtp.gmail.com
+#
+# Outlook:
+#   IMAP_HOST=outlook.office365.com
+#   SMTP_HOST=smtp.office365.com
+#   SMTP_PORT=587
+#   SMTP_SECURE=false
+#
+# Yahoo:
+#   IMAP_HOST=imap.mail.yahoo.com
+#   SMTP_HOST=smtp.mail.yahoo.com
+#
+# Fastmail:
+#   IMAP_HOST=imap.fastmail.com
+#   SMTP_HOST=smtp.fastmail.com

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+# IMAP Email MCP Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that provides email capabilities to Claude Code, Claude Desktop, Cursor, and other MCP-compatible AI tools. Connect to any IMAP/SMTP email provider to read, search, compose, and manage emails directly from your AI assistant.
+
+## Quick Start
+
+### Claude Code (CLI)
+
+**Important:** Claude Code CLI uses `claude mcp add`, not config files.
+
+```bash
+claude mcp add imap-email -s user \
+  -e IMAP_USER=you@example.com \
+  -e IMAP_PASSWORD='your-app-password' \
+  -e IMAP_HOST=imap.example.com \
+  -- npx -y imap-email-mcp
+```
+
+> **Note:** If your password contains special shell characters (`%`, `^`, `*`, `$`, `!`, etc.), wrap it in single quotes as shown above.
+
+> **Note:** Restart Claude Code after adding an MCP for the new tools to become available.
+
+Verify with:
+```bash
+claude mcp list
+claude mcp get imap-email
+```
+
+Remove with:
+```bash
+claude mcp remove imap-email -s user
+```
+
+### Cursor
+
+Add new MCP server:
+- **Name:** `imap-email`
+- **Type:** `command`
+- **Command:** `npx -y imap-email-mcp`
+
+Then set environment variables in Cursor's MCP settings:
+```
+IMAP_USER=your-email@example.com
+IMAP_PASSWORD=your-app-password
+IMAP_HOST=imap.example.com
+```
+
+### Claude Desktop
+
+Add to your config file:
+- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "imap-email": {
+      "command": "npx",
+      "args": ["-y", "imap-email-mcp"],
+      "env": {
+        "IMAP_USER": "your-email@example.com",
+        "IMAP_PASSWORD": "your-app-password",
+        "IMAP_HOST": "imap.example.com"
+      }
+    }
+  }
+}
+```
+
+## Features
+
+- **Read emails** - List and read emails from any folder
+- **Search** - Search by subject, sender, or body content
+- **Compose** - Create and save email drafts
+- **Send** - Send emails directly via SMTP
+- **Manage drafts** - List, read, update, and delete drafts
+- **Delete emails** - Remove unwanted messages
+- **Multi-provider support** - Works with Gmail, Outlook, Yahoo, Fastmail, and any standard IMAP provider
+
+## Configuration
+
+### Required Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `IMAP_USER` | Your email address |
+| `IMAP_PASSWORD` | App password (not your main password!) |
+| `IMAP_HOST` | IMAP server hostname |
+
+### Optional Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `IMAP_PORT` | `993` | IMAP port |
+| `IMAP_TLS` | `true` | Use TLS |
+| `SMTP_HOST` | Same as IMAP_HOST | SMTP server hostname |
+| `SMTP_PORT` | `465` | SMTP port |
+| `SMTP_SECURE` | `true` | Use secure SMTP |
+
+### Provider Settings
+
+| Provider | IMAP_HOST | SMTP_HOST | Notes |
+|----------|-----------|-----------|-------|
+| **Gmail** | `imap.gmail.com` | `smtp.gmail.com` | [Create App Password](https://myaccount.google.com/apppasswords) |
+| **Outlook** | `outlook.office365.com` | `smtp.office365.com` | Use port 587, SMTP_SECURE=false |
+| **Yahoo** | `imap.mail.yahoo.com` | `smtp.mail.yahoo.com` | Generate App Password in settings |
+| **Fastmail** | `imap.fastmail.com` | `smtp.fastmail.com` | App Password from Privacy & Security |
+| **iCloud** | `imap.mail.me.com` | `smtp.mail.me.com` | [Generate App Password](https://appleid.apple.com/) |
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_folders` | List all email folders/mailboxes |
+| `list_emails` | List emails with optional filtering |
+| `get_email` | Get full email content by UID |
+| `search_emails` | Search by subject, sender, or body |
+| `list_drafts` | List all draft emails |
+| `get_draft` | Get a specific draft by UID |
+| `create_draft` | Create a new email draft |
+| `update_draft` | Update an existing draft |
+| `send_email` | Send an email directly |
+| `delete_email` | Delete an email by UID |
+
+## Usage Examples
+
+Once configured, use natural language:
+
+- "Check my inbox for unread emails"
+- "Search for emails from john@example.com"
+- "Create a draft email to sarah@example.com about the meeting tomorrow"
+- "Show me my drafts folder"
+
+## Security Best Practices
+
+1. **Use App Passwords** - Never use your main account password
+2. **Environment Variables** - Store credentials in env vars, not in code
+3. **Review Before Sending** - Use `create_draft` instead of `send_email` to review first
+
+## Troubleshooting
+
+**Authentication failed**
+- Verify your app password is correct
+- Ensure IMAP access is enabled in your email provider's settings
+
+**Drafts folder not found**
+- The server tries common names (`Drafts`, `INBOX.Drafts`, `[Gmail]/Drafts`)
+- Your provider may use a different folder name
+
+**Connection timeout**
+- Check your `IMAP_HOST` is correct
+- Verify port 993 is not blocked by firewall
+
+## Alternative Installation
+
+### Install globally
+```bash
+npm install -g imap-email-mcp
+imap-email-mcp
+```
+
+### Clone and run
+```bash
+git clone https://github.com/jdickey1/imap-email-mcp.git
+cd imap-email-mcp
+npm install
+node index.js
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [npm package](https://www.npmjs.com/package/imap-email-mcp)
+- [GitHub repo](https://github.com/jdickey1/imap-email-mcp)
+- [MCP Protocol](https://modelcontextprotocol.io/)

package/index.js

@@ -0,0 +1,811 @@
+#!/usr/bin/env node
+
+/**
+ * IMAP Email MCP Server for Claude Code
+ *
+ * A Model Context Protocol (MCP) server that provides email capabilities
+ * through any IMAP/SMTP email provider.
+ *
+ * @license MIT
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import imaps from 'imap-simple';
+import { simpleParser } from 'mailparser';
+import nodemailer from 'nodemailer';
+
+// Configuration from environment variables
+const IMAP_CONFIG = {
+  imap: {
+    user: process.env.IMAP_USER,
+    password: process.env.IMAP_PASSWORD,
+    host: process.env.IMAP_HOST,
+    port: parseInt(process.env.IMAP_PORT || '993'),
+    tls: process.env.IMAP_TLS !== 'false',
+    authTimeout: parseInt(process.env.IMAP_AUTH_TIMEOUT || '10000'),
+    tlsOptions: {
+      rejectUnauthorized: process.env.IMAP_TLS_REJECT_UNAUTHORIZED !== 'false'
+    }
+  }
+};
+
+const SMTP_CONFIG = {
+  host: process.env.SMTP_HOST,
+  port: parseInt(process.env.SMTP_PORT || '465'),
+  secure: process.env.SMTP_SECURE !== 'false',
+  auth: {
+    user: process.env.SMTP_USER || process.env.IMAP_USER,
+    pass: process.env.SMTP_PASSWORD || process.env.IMAP_PASSWORD
+  }
+};
+
+// Traverse the raw IMAP MIME struct to find all attachment parts.
+//
+// Detection rules (in priority order):
+//   1. Content-Disposition is "attachment"                   → always an attachment
+//   2. Content-Disposition is "inline" or missing,
+//      a filename exists (from disposition params OR
+//      Content-Type "name" param), and the content-type
+//      is NOT text/plain or text/html                        → treat as attachment
+//
+// This catches real-world mailers that label attachments as
+// "inline" or omit Content-Disposition entirely.
+function findAttachmentParts(struct, parts = []) {
+  if (!Array.isArray(struct)) return parts;
+
+  for (const node of struct) {
+    if (Array.isArray(node)) {
+      // Nested multipart array — recurse
+      findAttachmentParts(node, parts);
+      continue;
+    }
+
+    if (typeof node !== 'object' || !node.type) continue;
+
+    const contentType = `${node.type}/${node.subtype}`.toLowerCase();
+    const disposition  = (node.disposition?.type  || '').toLowerCase();
+    const filename     =
+      node.disposition?.params?.filename ||
+      node.disposition?.params?.name     ||  // some clients use "name" here
+      node.params?.name;                      // fallback: Content-Type name param
+
+    const isAttachment =
+      disposition === 'attachment' ||
+      (
+        filename &&
+        contentType !== 'text/plain' &&
+        contentType !== 'text/html'
+      );
+
+    if (isAttachment) {
+      parts.push({ node, filename, contentType, disposition });
+    }
+  }
+
+  return parts;
+}
+
+// Validate required configuration
+function validateConfig() {
+  const required = ['IMAP_USER', 'IMAP_PASSWORD', 'IMAP_HOST'];
+  const missing = required.filter(key => !process.env[key]);
+
+  if (missing.length > 0) {
+    console.error(`Missing required environment variables: ${missing.join(', ')}`);
+    console.error('Please set these variables before starting the server.');
+    process.exit(1);
+  }
+
+  // SMTP host defaults to IMAP host if not set
+  if (!process.env.SMTP_HOST) {
+    SMTP_CONFIG.host = process.env.IMAP_HOST;
+  }
+}
+
+const server = new Server(
+  {
+    name: 'imap-email-mcp',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Tool definitions
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'list_folders',
+        description: 'List all email folders/mailboxes in the IMAP account',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: 'list_emails',
+        description: 'List emails from a folder with optional filtering',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            folder: {
+              type: 'string',
+              description: 'Folder name (default: INBOX)',
+              default: 'INBOX'
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum number of emails to return (default: 20)',
+              default: 20
+            },
+            unseen_only: {
+              type: 'boolean',
+              description: 'Only return unread emails',
+              default: false
+            },
+            since_date: {
+              type: 'string',
+              description: 'Only return emails since this date (YYYY-MM-DD format)'
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: 'get_email',
+        description: 'Get full email content by UID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID'
+            },
+            folder: {
+              type: 'string',
+              description: 'Folder name (default: INBOX)',
+              default: 'INBOX'
+            }
+          },
+          required: ['uid']
+        }
+      },
+      {
+        name: 'search_emails',
+        description: 'Search emails by subject, from, or body text',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            folder: {
+              type: 'string',
+              description: 'Folder to search (default: INBOX)',
+              default: 'INBOX'
+            },
+            subject: {
+              type: 'string',
+              description: 'Search in subject line'
+            },
+            from: {
+              type: 'string',
+              description: 'Search by sender'
+            },
+            body: {
+              type: 'string',
+              description: 'Search in body text'
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum results (default: 20)',
+              default: 20
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: 'list_drafts',
+        description: 'List all draft emails',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            limit: {
+              type: 'number',
+              description: 'Maximum number of drafts to return (default: 20)',
+              default: 20
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: 'get_draft',
+        description: 'Get a specific draft email by UID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Draft UID'
+            }
+          },
+          required: ['uid']
+        }
+      },
+      {
+        name: 'create_draft',
+        description: 'Create a new draft email',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            to: {
+              type: 'string',
+              description: 'Recipient email address(es), comma-separated'
+            },
+            subject: {
+              type: 'string',
+              description: 'Email subject'
+            },
+            body: {
+              type: 'string',
+              description: 'Email body (plain text)'
+            },
+            html: {
+              type: 'string',
+              description: 'Email body (HTML)'
+            },
+            cc: {
+              type: 'string',
+              description: 'CC recipients, comma-separated'
+            },
+            bcc: {
+              type: 'string',
+              description: 'BCC recipients, comma-separated'
+            }
+          },
+          required: ['to', 'subject']
+        }
+      },
+      {
+        name: 'update_draft',
+        description: 'Update an existing draft by deleting old and creating new',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'UID of draft to update'
+            },
+            to: {
+              type: 'string',
+              description: 'Recipient email address(es)'
+            },
+            subject: {
+              type: 'string',
+              description: 'Email subject'
+            },
+            body: {
+              type: 'string',
+              description: 'Email body (plain text)'
+            },
+            html: {
+              type: 'string',
+              description: 'Email body (HTML)'
+            },
+            cc: {
+              type: 'string',
+              description: 'CC recipients'
+            },
+            bcc: {
+              type: 'string',
+              description: 'BCC recipients'
+            }
+          },
+          required: ['uid', 'to', 'subject']
+        }
+      },
+      {
+        name: 'send_email',
+        description: 'Send an email directly',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            to: {
+              type: 'string',
+              description: 'Recipient email address(es)'
+            },
+            subject: {
+              type: 'string',
+              description: 'Email subject'
+            },
+            body: {
+              type: 'string',
+              description: 'Email body (plain text)'
+            },
+            html: {
+              type: 'string',
+              description: 'Email body (HTML)'
+            },
+            cc: {
+              type: 'string',
+              description: 'CC recipients'
+            },
+            bcc: {
+              type: 'string',
+              description: 'BCC recipients'
+            }
+          },
+          required: ['to', 'subject']
+        }
+      },
+      {
+        name: 'delete_email',
+        description: 'Delete an email by UID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID to delete'
+            },
+            folder: {
+              type: 'string',
+              description: 'Folder name (default: INBOX)',
+              default: 'INBOX'
+            }
+          },
+          required: ['uid']
+        }
+      }
+    ]
+  };
+});
+
+// Helper function to connect to IMAP
+async function connectIMAP() {
+  if (!IMAP_CONFIG.imap.password) {
+    throw new Error('IMAP_PASSWORD environment variable is not set');
+  }
+  return await imaps.connect(IMAP_CONFIG);
+}
+
+// Helper to find drafts folder (handles different provider conventions)
+async function findDraftsFolder(connection) {
+  const boxes = await connection.getBoxes();
+
+  // Common drafts folder names across providers
+  const draftNames = [
+    'Drafts',
+    'INBOX.Drafts',
+    '[Gmail]/Drafts',
+    '[Google Mail]/Drafts',
+    'Draft',
+    'INBOX/Drafts'
+  ];
+
+  for (const name of draftNames) {
+    if (boxes[name] || name.split('.').reduce((acc, part) => acc?.[part], boxes)) {
+      return name;
+    }
+  }
+
+  // Check for nested Drafts under INBOX
+  if (boxes.INBOX && boxes.INBOX.children && boxes.INBOX.children.Drafts) {
+    return 'INBOX.Drafts';
+  }
+
+  return 'Drafts'; // Default fallback
+}
+
+// Tool handlers
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'list_folders': {
+        const connection = await connectIMAP();
+        try {
+          const boxes = await connection.getBoxes();
+          const folders = [];
+
+          function extractFolders(obj, prefix = '') {
+            for (const [key, value] of Object.entries(obj)) {
+              const fullPath = prefix ? `${prefix}.${key}` : key;
+              folders.push(fullPath);
+              if (value.children) {
+                extractFolders(value.children, fullPath);
+              }
+            }
+          }
+
+          extractFolders(boxes);
+          return { content: [{ type: 'text', text: JSON.stringify(folders, null, 2) }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'list_emails': {
+        const folder = args.folder || 'INBOX';
+        const limit = args.limit || 20;
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          let searchCriteria = ['ALL'];
+          if (args.unseen_only) {
+            searchCriteria = ['UNSEEN'];
+          }
+          if (args.since_date) {
+            searchCriteria = [['SINCE', args.since_date]];
+          }
+
+          const fetchOptions = {
+            bodies: ['HEADER.FIELDS (FROM TO SUBJECT DATE)'],
+            struct: true
+          };
+
+          const messages = await connection.search(searchCriteria, fetchOptions);
+          const results = messages.slice(-limit).reverse().map(msg => {
+            const header = msg.parts.find(p => p.which.includes('HEADER'))?.body || {};
+            return {
+              uid: msg.attributes.uid,
+              date: header.date?.[0],
+              from: header.from?.[0],
+              to: header.to?.[0],
+              subject: header.subject?.[0],
+              flags: msg.attributes.flags
+            };
+          });
+
+          return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'get_email': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          const fetchOptions = {
+            bodies: [''],
+            struct: true
+          };
+
+          const messages = await connection.search([['UID', args.uid]], fetchOptions);
+
+          if (messages.length === 0) {
+            return { content: [{ type: 'text', text: 'Email not found' }] };
+          }
+
+          const msg = messages[0];
+          const rawBody = msg.parts.find(p => p.which === '')?.body;
+          const parsed = await simpleParser(rawBody);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                uid: msg.attributes.uid,
+                from: parsed.from?.text,
+                to: parsed.to?.text,
+                cc: parsed.cc?.text,
+                subject: parsed.subject,
+                date: parsed.date,
+                text: parsed.text,
+                html: parsed.html,
+                attachments: (() => {
+                  // Start with what mailparser found (covers Content-Disposition: attachment
+                  // and inline+filename cases for content it fully parsed).
+                  const fromParser = new Map(
+                    (parsed.attachments || []).map(a => [
+                      (a.filename || '').toLowerCase(),
+                      { filename: a.filename, contentType: a.contentType, size: a.size }
+                    ])
+                  );
+
+                  // Also walk the raw MIME struct so we catch parts that mailparser
+                  // may have skipped: inline parts with filenames and parts that have
+                  // no Content-Disposition at all but carry a Content-Type "name" param.
+                  const fromStruct = findAttachmentParts(msg.attributes.struct || []);
+                  for (const { filename, contentType } of fromStruct) {
+                    const key = (filename || '').toLowerCase();
+                    if (filename && !fromParser.has(key)) {
+                      fromParser.set(key, { filename, contentType, size: null });
+                    }
+                  }
+
+                  return [...fromParser.values()];
+                })()
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'search_emails': {
+        const folder = args.folder || 'INBOX';
+        const limit = args.limit || 20;
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          let searchCriteria = [];
+          if (args.subject) searchCriteria.push(['SUBJECT', args.subject]);
+          if (args.from) searchCriteria.push(['FROM', args.from]);
+          if (args.body) searchCriteria.push(['BODY', args.body]);
+
+          if (searchCriteria.length === 0) {
+            searchCriteria = ['ALL'];
+          }
+
+          const fetchOptions = {
+            bodies: ['HEADER.FIELDS (FROM TO SUBJECT DATE)'],
+            struct: true
+          };
+
+          const messages = await connection.search(searchCriteria, fetchOptions);
+          const results = messages.slice(-limit).reverse().map(msg => {
+            const header = msg.parts.find(p => p.which.includes('HEADER'))?.body || {};
+            return {
+              uid: msg.attributes.uid,
+              date: header.date?.[0],
+              from: header.from?.[0],
+              to: header.to?.[0],
+              subject: header.subject?.[0]
+            };
+          });
+
+          return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'list_drafts': {
+        const limit = args.limit || 20;
+        const connection = await connectIMAP();
+
+        try {
+          const draftsFolder = await findDraftsFolder(connection);
+          await connection.openBox(draftsFolder);
+
+          const fetchOptions = {
+            bodies: ['HEADER.FIELDS (FROM TO SUBJECT DATE)'],
+            struct: true
+          };
+
+          const messages = await connection.search(['ALL'], fetchOptions);
+          const results = messages.slice(-limit).reverse().map(msg => {
+            const header = msg.parts.find(p => p.which.includes('HEADER'))?.body || {};
+            return {
+              uid: msg.attributes.uid,
+              date: header.date?.[0],
+              to: header.to?.[0],
+              subject: header.subject?.[0]
+            };
+          });
+
+          return { content: [{ type: 'text', text: JSON.stringify({ folder: draftsFolder, drafts: results }, null, 2) }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'get_draft': {
+        const connection = await connectIMAP();
+
+        try {
+          const draftsFolder = await findDraftsFolder(connection);
+          await connection.openBox(draftsFolder);
+
+          const fetchOptions = {
+            bodies: [''],
+            struct: true
+          };
+
+          const messages = await connection.search([['UID', args.uid]], fetchOptions);
+
+          if (messages.length === 0) {
+            return { content: [{ type: 'text', text: 'Draft not found' }] };
+          }
+
+          const msg = messages[0];
+          const rawBody = msg.parts.find(p => p.which === '')?.body;
+          const parsed = await simpleParser(rawBody);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                uid: msg.attributes.uid,
+                to: parsed.to?.text,
+                cc: parsed.cc?.text,
+                bcc: parsed.bcc?.text,
+                subject: parsed.subject,
+                date: parsed.date,
+                text: parsed.text,
+                html: parsed.html
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'create_draft': {
+        const connection = await connectIMAP();
+
+        try {
+          const draftsFolder = await findDraftsFolder(connection);
+
+          // Build RFC 2822 compliant email message
+          const boundary = `----=_Part_${Date.now()}`;
+          let message = '';
+          message += `From: ${IMAP_CONFIG.imap.user}\r\n`;
+          message += `To: ${args.to}\r\n`;
+          if (args.cc) message += `Cc: ${args.cc}\r\n`;
+          if (args.bcc) message += `Bcc: ${args.bcc}\r\n`;
+          message += `Subject: ${args.subject}\r\n`;
+          message += `Date: ${new Date().toUTCString()}\r\n`;
+          message += `MIME-Version: 1.0\r\n`;
+
+          if (args.html) {
+            message += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n\r\n`;
+            message += `--${boundary}\r\n`;
+            message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+            message += `${args.body || ''}\r\n`;
+            message += `--${boundary}\r\n`;
+            message += `Content-Type: text/html; charset=utf-8\r\n\r\n`;
+            message += `${args.html}\r\n`;
+            message += `--${boundary}--\r\n`;
+          } else {
+            message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+            message += `${args.body || ''}\r\n`;
+          }
+
+          await connection.append(message, { mailbox: draftsFolder, flags: ['\\Draft'] });
+
+          return { content: [{ type: 'text', text: `Draft created successfully in ${draftsFolder}` }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'update_draft': {
+        const connection = await connectIMAP();
+
+        try {
+          const draftsFolder = await findDraftsFolder(connection);
+          await connection.openBox(draftsFolder);
+
+          // Delete old draft
+          await connection.addFlags(args.uid, ['\\Deleted']);
+          await connection.closeBox(true); // Expunge
+
+          // Create new draft
+          await connection.openBox(draftsFolder);
+
+          const boundary = `----=_Part_${Date.now()}`;
+          let message = '';
+          message += `From: ${IMAP_CONFIG.imap.user}\r\n`;
+          message += `To: ${args.to}\r\n`;
+          if (args.cc) message += `Cc: ${args.cc}\r\n`;
+          if (args.bcc) message += `Bcc: ${args.bcc}\r\n`;
+          message += `Subject: ${args.subject}\r\n`;
+          message += `Date: ${new Date().toUTCString()}\r\n`;
+          message += `MIME-Version: 1.0\r\n`;
+
+          if (args.html) {
+            message += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n\r\n`;
+            message += `--${boundary}\r\n`;
+            message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+            message += `${args.body || ''}\r\n`;
+            message += `--${boundary}\r\n`;
+            message += `Content-Type: text/html; charset=utf-8\r\n\r\n`;
+            message += `${args.html}\r\n`;
+            message += `--${boundary}--\r\n`;
+          } else {
+            message += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+            message += `${args.body || ''}\r\n`;
+          }
+
+          await connection.append(message, { mailbox: draftsFolder, flags: ['\\Draft'] });
+
+          return { content: [{ type: 'text', text: 'Draft updated successfully' }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'send_email': {
+        if (!SMTP_CONFIG.host) {
+          return {
+            content: [{ type: 'text', text: 'Error: SMTP_HOST not configured. Cannot send emails.' }],
+            isError: true
+          };
+        }
+
+        const transporter = nodemailer.createTransport(SMTP_CONFIG);
+
+        const mailOptions = {
+          from: SMTP_CONFIG.auth.user,
+          to: args.to,
+          subject: args.subject,
+          text: args.body,
+          html: args.html,
+          cc: args.cc,
+          bcc: args.bcc
+        };
+
+        const info = await transporter.sendMail(mailOptions);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              messageId: info.messageId,
+              response: info.response
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'delete_email': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+          await connection.addFlags(args.uid, ['\\Deleted']);
+          await connection.closeBox(true); // Expunge
+
+          return { content: [{ type: 'text', text: 'Email deleted successfully' }] };
+        } finally {
+          connection.end();
+        }
+      }
+
+      default:
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Error: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+});
+
+// Start server
+async function main() {
+  validateConfig();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('IMAP Email MCP Server running on stdio');
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@lengelhard/imap-email-mcp",
+  "version": "1.0.1",
+  "description": "MCP server for Claude Code that provides email capabilities through IMAP/SMTP. Read, search, compose, and manage emails from any IMAP provider.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "imap-email-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "email",
+    "imap",
+    "smtp",
+    "mail",
+    "inbox",
+    "gmail",
+    "outlook",
+    "email-client",
+    "ai-tools",
+    "llm-tools"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lengelhard/imap-email-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lengelhard/imap-email-mcp/issues"
+  },
+  "homepage": "https://github.com/lengelhard/imap-email-mcp#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "imap-simple": "^5.1.0",
+    "mailparser": "^3.7.2",
+    "nodemailer": "^6.9.16"
+  }
+}