@forwardemail/mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Forward Email LLC
+Licensed Work:        @forwardemail/mcp-server
+                      The Licensed Work is (c) 2025 Forward Email LLC.
+Additional Use Grant: You may make use of the Licensed Work, provided that
+                      you may not use the Licensed Work for an Email Service
+                      that is Competitive with the Licensed Work.
+
+                      A "Competitive" service is a service that offers
+                      email forwarding, email hosting, or email API services
+                      that are substantially similar to those offered by
+                      Forward Email (https://forwardemail.net).
+
+Change Date:          Four years from the date the Licensed Work is published.
+
+Change License:       MIT
+
+For information about alternative licensing arrangements for the Licensed Work,
+please visit: https://forwardemail.net

package/README.md

@@ -0,0 +1,211 @@
+# @forwardemail/mcp-server
+
+[Model Context Protocol](https://github.com/modelcontextprotocol/specification) (MCP) server for [Forward Email](https://forwardemail.net). Connect AI assistants to your inbox.
+
+## Overview
+
+This package provides a local MCP server that wraps the [Forward Email API](https://forwardemail.net/email-api). It lets AI agents (Claude, ChatGPT, Cursor, Windsurf, and others) send email, manage domains, and read your inbox through natural language.
+
+The server runs locally on your machine via `stdio`. Your API key never leaves your device.
+
+## Install
+
+```bash
+npm install -g @forwardemail/mcp-server
+```
+
+Or run directly with `npx`:
+
+```bash
+npx @forwardemail/mcp-server
+```
+
+## Setup
+
+### 1. Get your API key
+
+Log in at <https://forwardemail.net/my-account/security> and copy your API key.
+
+### 2. Set the environment variable
+
+```bash
+export FORWARD_EMAIL_API_KEY=your-api-key
+```
+
+### 3. Configure your AI client
+
+#### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "forwardemail": {
+      "command": "npx",
+      "args": ["@forwardemail/mcp-server"],
+      "env": {
+        "FORWARD_EMAIL_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+#### Cursor
+
+Add to `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "forwardemail": {
+      "command": "npx",
+      "args": ["@forwardemail/mcp-server"],
+      "env": {
+        "FORWARD_EMAIL_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+This server exposes the complete [Forward Email API](https://forwardemail.net/email-api) as MCP tools. Every endpoint is covered.
+
+### Account
+
+* `getAccount` - Get your account details
+* `updateAccount` - Update your account
+
+### Logs
+
+* `downloadLogs` - Download email delivery logs
+
+### Contacts (CardDAV)
+
+* `listContacts` - List all contacts
+* `createContact` - Create a contact
+* `getContact` - Get a contact by ID
+* `updateContact` - Update a contact
+* `deleteContact` - Delete a contact
+
+### Calendars (CalDAV)
+
+* `listCalendars` - List all calendars
+* `createCalendar` - Create a calendar
+* `getCalendar` - Get a calendar by ID
+* `updateCalendar` - Update a calendar
+* `deleteCalendar` - Delete a calendar
+
+### Calendar Events (CalDAV)
+
+* `listCalendarEvents` - List all calendar events
+* `createCalendarEvent` - Create a calendar event
+* `getCalendarEvent` - Get a calendar event by ID
+* `updateCalendarEvent` - Update a calendar event
+* `deleteCalendarEvent` - Delete a calendar event
+
+### Domains
+
+* `listDomains` - List all domains
+* `createDomain` - Create a new domain
+* `getDomain` - Get a domain by ID or name
+* `updateDomain` - Update a domain
+* `deleteDomain` - Delete a domain
+* `verifyDomainRecords` - Verify domain DNS records
+* `verifySmtpRecords` - Verify domain SMTP records
+* `testS3Connection` - Test custom S3 connection for a domain
+
+### Domain Catch-All Passwords
+
+* `listCatchAllPasswords` - List domain-wide catch-all passwords
+* `createCatchAllPassword` - Create a domain-wide catch-all password
+* `deleteCatchAllPassword` - Remove a domain-wide catch-all password
+
+### Domain Invites
+
+* `acceptDomainInvite` - Accept a domain invite
+* `createDomainInvite` - Invite a user to a domain
+* `removeDomainInvite` - Remove a domain invite
+
+### Domain Members
+
+* `updateDomainMember` - Update a domain member role
+* `removeDomainMember` - Remove a member from a domain
+
+### Aliases
+
+* `listAliases` - List aliases for a domain
+* `createAlias` - Create a new alias
+* `getAlias` - Get an alias by ID
+* `updateAlias` - Update an alias
+* `deleteAlias` - Delete an alias
+* `generateAliasPassword` - Generate or set a password for an alias
+
+### Sieve Scripts
+
+* `listSieveScripts` - List Sieve scripts for an alias
+* `createSieveScript` - Create a Sieve script for an alias
+* `getSieveScript` - Get a Sieve script by ID
+* `updateSieveScript` - Update a Sieve script
+* `deleteSieveScript` - Delete a Sieve script
+* `activateSieveScript` - Activate a Sieve script
+
+### Sieve Scripts (Alias Auth)
+
+* `listSieveScriptsAliasAuth` - List Sieve scripts (alias auth)
+* `createSieveScriptAliasAuth` - Create a Sieve script (alias auth)
+* `getSieveScriptAliasAuth` - Get a Sieve script (alias auth)
+* `updateSieveScriptAliasAuth` - Update a Sieve script (alias auth)
+* `deleteSieveScriptAliasAuth` - Delete a Sieve script (alias auth)
+* `activateSieveScriptAliasAuth` - Activate a Sieve script (alias auth)
+
+### Emails (Outbound SMTP)
+
+* `listEmails` - List outbound SMTP emails
+* `sendEmail` - Send an email via outbound SMTP
+* `getEmailLimit` - Get outbound SMTP email sending limit
+* `getEmail` - Get an outbound SMTP email by ID
+* `deleteEmail` - Delete an outbound SMTP email
+
+### Messages (IMAP)
+
+* `listMessages` - List and search messages in a folder
+* `createMessage` - Create a new message (draft)
+* `getMessage` - Get a message by ID
+* `updateMessage` - Update a message
+* `deleteMessage` - Delete a message
+
+### Folders (IMAP)
+
+* `listFolders` - List all folders
+* `createFolder` - Create a new folder
+* `getFolder` - Get a folder by ID
+* `updateFolder` - Update a folder
+* `deleteFolder` - Delete a folder
+
+### Encrypt
+
+* `encryptRecord` - Encrypt a plaintext Forward Email TXT record
+
+## Development
+
+```bash
+git clone https://github.com/forwardemail/mcp-server.git
+cd mcp-server
+pnpm install
+pnpm test
+```
+
+## License
+
+[BUSL-1.1](LICENSE)
+
+## Links
+
+* [Forward Email](https://forwardemail.net)
+* [Forward Email API Docs](https://forwardemail.net/email-api)
+* [MCP Specification](https://github.com/modelcontextprotocol/specification)
+* [MCP Landing Page](https://forwardemail.net/mcp)

package/bin/mcp-server.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+const {McpServer} = require('../lib/index.js');
+
+const server = new McpServer();
+server.listen();

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export type McpServerOptions = {
+  apiKey?: string;
+  baseURL?: string;
+};
+
+export class McpServer {
+  constructor(options?: McpServerOptions);
+  listen(): void;
+}

package/lib/index.js

@@ -0,0 +1,63 @@
+const readline = require('node:readline');
+const {getTools} = require('./tools.js');
+
+class McpServer {
+  constructor(options = {}) {
+    this.tools = getTools(options);
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false,
+    });
+  }
+
+  listen() {
+    this.rl.on('line', async (line) => {
+      try {
+        const request = JSON.parse(line);
+        await this.handleRequest(request);
+      } catch (error) {
+        this.sendError(error.message);
+      }
+    });
+  }
+
+  async handleRequest(request) {
+    if (request.type === 'listTools') {
+      return this.sendResponse(request.id, {
+        tools: Object.values(this.tools).map((tool) => tool.toolSpec),
+      });
+    }
+
+    if (request.type === 'invokeTool') {
+      const tool = this.tools[request.name];
+      if (tool) {
+        try {
+          const result = await tool.invoke(request.arguments);
+          return this.sendResponse(request.id, {result});
+        } catch (error) {
+          const errorMessage = error.response?.data?.message || error.message;
+          return this.sendError(errorMessage, request.id);
+        }
+      }
+
+      return this.sendError(`Tool not found: ${request.name}`, request.id);
+    }
+
+    return this.sendError(`Unknown request type: ${request.type}`, request.id);
+  }
+
+  sendResponse(id, payload) {
+    this.send({type: 'toolResponse', id, ...payload});
+  }
+
+  sendError(message, id = null) {
+    this.send({type: 'error', id, message});
+  }
+
+  send(data) {
+    process.stdout.write(JSON.stringify(data) + '\n');
+  }
+}
+
+module.exports = {McpServer};

package/lib/tools.js

@@ -0,0 +1,577 @@
+const axios = require('axios');
+
+const getTools = (options = {}) => {
+  const client = axios.create({
+    baseURL: options.baseURL || 'https://api.forwardemail.net',
+    headers: {
+      Authorization: `Bearer ${options.apiKey || process.env.FORWARD_EMAIL_API_KEY}`,
+    },
+  });
+
+  const createTool = (spec) => ({
+    toolSpec: {
+      name: spec.name,
+      description: spec.description,
+      input: {
+        type: 'object',
+        properties: spec.inputs || {},
+      },
+    },
+    async invoke(arguments_) {
+      let {path} = spec;
+      const pathParameters = path.match(/{(\w+)}/g) || [];
+      const queryArguments = {};
+      const bodyArguments = {};
+
+      for (const key in arguments_) {
+        if (Object.hasOwn(arguments_, key)) {
+          if (pathParameters.includes(`{${key}}`)) {
+            path = path.replace(`{${key}}`, arguments_[key]);
+          } else if (spec.query && spec.query.includes(key)) {
+            queryArguments[key] = arguments_[key];
+          } else {
+            bodyArguments[key] = arguments_[key];
+          }
+        }
+      }
+
+      const config = {params: queryArguments};
+      const hasBody = Object.keys(bodyArguments).length > 0;
+
+      let response;
+      if (spec.method === 'get' || spec.method === 'delete') {
+        response = await client[spec.method](path, config);
+      } else {
+        response = await client[spec.method](
+          path,
+          hasBody ? bodyArguments : undefined,
+          config,
+        );
+      }
+
+      return response.data;
+    },
+  });
+
+  const tools = {
+    //
+    // Account
+    //
+    getAccount: createTool({
+      name: 'getAccount',
+      description: 'Get your account details',
+      method: 'get',
+      path: '/v1/account',
+    }),
+    updateAccount: createTool({
+      name: 'updateAccount',
+      description: 'Update your account',
+      method: 'put',
+      path: '/v1/account',
+    }),
+
+    //
+    // Logs
+    //
+    downloadLogs: createTool({
+      name: 'downloadLogs',
+      description: 'Download email delivery logs',
+      method: 'get',
+      path: '/v1/logs/download',
+      query: [
+        'domain',
+        'q',
+        'bounce_category',
+        'response_code',
+        'always_send_email',
+      ],
+    }),
+
+    //
+    // Contacts (CardDAV)
+    //
+    listContacts: createTool({
+      name: 'listContacts',
+      description: 'List all contacts',
+      method: 'get',
+      path: '/v1/contacts',
+    }),
+    createContact: createTool({
+      name: 'createContact',
+      description: 'Create a contact',
+      method: 'post',
+      path: '/v1/contacts',
+    }),
+    getContact: createTool({
+      name: 'getContact',
+      description: 'Get a contact by ID',
+      method: 'get',
+      path: '/v1/contacts/{id}',
+    }),
+    updateContact: createTool({
+      name: 'updateContact',
+      description: 'Update a contact',
+      method: 'put',
+      path: '/v1/contacts/{id}',
+    }),
+    deleteContact: createTool({
+      name: 'deleteContact',
+      description: 'Delete a contact',
+      method: 'delete',
+      path: '/v1/contacts/{id}',
+    }),
+
+    //
+    // Calendars (CalDAV)
+    //
+    listCalendars: createTool({
+      name: 'listCalendars',
+      description: 'List all calendars',
+      method: 'get',
+      path: '/v1/calendars',
+    }),
+    createCalendar: createTool({
+      name: 'createCalendar',
+      description: 'Create a calendar',
+      method: 'post',
+      path: '/v1/calendars',
+    }),
+    getCalendar: createTool({
+      name: 'getCalendar',
+      description: 'Get a calendar by ID',
+      method: 'get',
+      path: '/v1/calendars/{id}',
+    }),
+    updateCalendar: createTool({
+      name: 'updateCalendar',
+      description: 'Update a calendar',
+      method: 'put',
+      path: '/v1/calendars/{id}',
+    }),
+    deleteCalendar: createTool({
+      name: 'deleteCalendar',
+      description: 'Delete a calendar',
+      method: 'delete',
+      path: '/v1/calendars/{id}',
+    }),
+
+    //
+    // Calendar Events (CalDAV)
+    //
+    listCalendarEvents: createTool({
+      name: 'listCalendarEvents',
+      description: 'List all calendar events',
+      method: 'get',
+      path: '/v1/calendar-events',
+    }),
+    createCalendarEvent: createTool({
+      name: 'createCalendarEvent',
+      description: 'Create a calendar event',
+      method: 'post',
+      path: '/v1/calendar-events',
+    }),
+    getCalendarEvent: createTool({
+      name: 'getCalendarEvent',
+      description: 'Get a calendar event by ID',
+      method: 'get',
+      path: '/v1/calendar-events/{id}',
+    }),
+    updateCalendarEvent: createTool({
+      name: 'updateCalendarEvent',
+      description: 'Update a calendar event',
+      method: 'put',
+      path: '/v1/calendar-events/{id}',
+    }),
+    deleteCalendarEvent: createTool({
+      name: 'deleteCalendarEvent',
+      description: 'Delete a calendar event',
+      method: 'delete',
+      path: '/v1/calendar-events/{id}',
+    }),
+
+    //
+    // Domains
+    //
+    listDomains: createTool({
+      name: 'listDomains',
+      description: 'List all domains',
+      method: 'get',
+      path: '/v1/domains',
+      query: ['sort', 'page', 'limit'],
+    }),
+    createDomain: createTool({
+      name: 'createDomain',
+      description: 'Create a new domain',
+      method: 'post',
+      path: '/v1/domains',
+    }),
+    getDomain: createTool({
+      name: 'getDomain',
+      description: 'Get a domain by ID or name',
+      method: 'get',
+      path: '/v1/domains/{domain_id}',
+    }),
+    updateDomain: createTool({
+      name: 'updateDomain',
+      description: 'Update a domain',
+      method: 'put',
+      path: '/v1/domains/{domain_id}',
+    }),
+    deleteDomain: createTool({
+      name: 'deleteDomain',
+      description: 'Delete a domain',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}',
+    }),
+    verifyDomainRecords: createTool({
+      name: 'verifyDomainRecords',
+      description: 'Verify domain DNS records',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/verify-records',
+    }),
+    verifySmtpRecords: createTool({
+      name: 'verifySmtpRecords',
+      description: 'Verify domain SMTP records',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/verify-smtp',
+    }),
+    testS3Connection: createTool({
+      name: 'testS3Connection',
+      description: 'Test custom S3 connection for a domain',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/test-s3-connection',
+    }),
+
+    //
+    // Domain Catch-All Passwords
+    //
+    listCatchAllPasswords: createTool({
+      name: 'listCatchAllPasswords',
+      description: 'List domain-wide catch-all passwords',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/catch-all-passwords',
+    }),
+    createCatchAllPassword: createTool({
+      name: 'createCatchAllPassword',
+      description: 'Create a domain-wide catch-all password',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/catch-all-passwords',
+    }),
+    deleteCatchAllPassword: createTool({
+      name: 'deleteCatchAllPassword',
+      description: 'Remove a domain-wide catch-all password',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}/catch-all-passwords/{token_id}',
+    }),
+
+    //
+    // Domain Invites
+    //
+    acceptDomainInvite: createTool({
+      name: 'acceptDomainInvite',
+      description: 'Accept a domain invite',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/invites',
+    }),
+    createDomainInvite: createTool({
+      name: 'createDomainInvite',
+      description: 'Invite a user to a domain',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/invites',
+    }),
+    removeDomainInvite: createTool({
+      name: 'removeDomainInvite',
+      description: 'Remove a domain invite',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}/invites',
+    }),
+
+    //
+    // Domain Members
+    //
+    updateDomainMember: createTool({
+      name: 'updateDomainMember',
+      description: 'Update a domain member role (admin or user)',
+      method: 'put',
+      path: '/v1/domains/{domain_id}/members/{member_id}',
+    }),
+    removeDomainMember: createTool({
+      name: 'removeDomainMember',
+      description: 'Remove a member from a domain',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}/members/{member_id}',
+    }),
+
+    //
+    // Aliases
+    //
+    listAliases: createTool({
+      name: 'listAliases',
+      description: 'List aliases for a domain',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/aliases',
+      query: ['sort', 'page', 'limit'],
+    }),
+    createAlias: createTool({
+      name: 'createAlias',
+      description: 'Create a new alias',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/aliases',
+    }),
+    getAlias: createTool({
+      name: 'getAlias',
+      description: 'Get an alias by ID',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}',
+    }),
+    updateAlias: createTool({
+      name: 'updateAlias',
+      description: 'Update an alias',
+      method: 'put',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}',
+    }),
+    deleteAlias: createTool({
+      name: 'deleteAlias',
+      description: 'Delete an alias',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}',
+    }),
+    generateAliasPassword: createTool({
+      name: 'generateAliasPassword',
+      description: 'Generate or set a password for an alias',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/generate-password',
+    }),
+
+    //
+    // Sieve Scripts (domain-scoped, authenticated via API key)
+    //
+    listSieveScripts: createTool({
+      name: 'listSieveScripts',
+      description: 'List Sieve scripts for an alias',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve',
+    }),
+    createSieveScript: createTool({
+      name: 'createSieveScript',
+      description: 'Create a Sieve script for an alias',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve',
+    }),
+    getSieveScript: createTool({
+      name: 'getSieveScript',
+      description: 'Get a Sieve script by ID',
+      method: 'get',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve/{script_id}',
+    }),
+    updateSieveScript: createTool({
+      name: 'updateSieveScript',
+      description: 'Update a Sieve script',
+      method: 'put',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve/{script_id}',
+    }),
+    deleteSieveScript: createTool({
+      name: 'deleteSieveScript',
+      description: 'Delete a Sieve script',
+      method: 'delete',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve/{script_id}',
+    }),
+    activateSieveScript: createTool({
+      name: 'activateSieveScript',
+      description: 'Activate a Sieve script',
+      method: 'post',
+      path: '/v1/domains/{domain_id}/aliases/{alias_id}/sieve/{script_id}/activate',
+    }),
+
+    //
+    // Sieve Scripts (alias auth, authenticated via alias credentials)
+    //
+    listSieveScriptsAliasAuth: createTool({
+      name: 'listSieveScriptsAliasAuth',
+      description: 'List Sieve scripts (alias auth)',
+      method: 'get',
+      path: '/v1/sieve-scripts',
+    }),
+    createSieveScriptAliasAuth: createTool({
+      name: 'createSieveScriptAliasAuth',
+      description: 'Create a Sieve script (alias auth)',
+      method: 'post',
+      path: '/v1/sieve-scripts',
+    }),
+    getSieveScriptAliasAuth: createTool({
+      name: 'getSieveScriptAliasAuth',
+      description: 'Get a Sieve script (alias auth)',
+      method: 'get',
+      path: '/v1/sieve-scripts/{script_id}',
+    }),
+    updateSieveScriptAliasAuth: createTool({
+      name: 'updateSieveScriptAliasAuth',
+      description: 'Update a Sieve script (alias auth)',
+      method: 'put',
+      path: '/v1/sieve-scripts/{script_id}',
+    }),
+    deleteSieveScriptAliasAuth: createTool({
+      name: 'deleteSieveScriptAliasAuth',
+      description: 'Delete a Sieve script (alias auth)',
+      method: 'delete',
+      path: '/v1/sieve-scripts/{script_id}',
+    }),
+    activateSieveScriptAliasAuth: createTool({
+      name: 'activateSieveScriptAliasAuth',
+      description: 'Activate a Sieve script (alias auth)',
+      method: 'post',
+      path: '/v1/sieve-scripts/{script_id}/activate',
+    }),
+
+    //
+    // Emails (Outbound SMTP)
+    //
+    listEmails: createTool({
+      name: 'listEmails',
+      description: 'List outbound SMTP emails',
+      method: 'get',
+      path: '/v1/emails',
+      query: ['q', 'domain', 'is_scheduled', 'sort', 'page', 'limit'],
+    }),
+    sendEmail: createTool({
+      name: 'sendEmail',
+      description: 'Send an email via outbound SMTP',
+      method: 'post',
+      path: '/v1/emails',
+    }),
+    getEmailLimit: createTool({
+      name: 'getEmailLimit',
+      description: 'Get outbound SMTP email sending limit',
+      method: 'get',
+      path: '/v1/emails/limit',
+    }),
+    getEmail: createTool({
+      name: 'getEmail',
+      description: 'Get an outbound SMTP email by ID',
+      method: 'get',
+      path: '/v1/emails/{id}',
+    }),
+    deleteEmail: createTool({
+      name: 'deleteEmail',
+      description: 'Delete an outbound SMTP email',
+      method: 'delete',
+      path: '/v1/emails/{id}',
+    }),
+
+    //
+    // Messages (IMAP)
+    //
+    listMessages: createTool({
+      name: 'listMessages',
+      description: 'List and search messages in a folder',
+      method: 'get',
+      path: '/v1/messages',
+      query: [
+        'folder',
+        'is_unread',
+        'is_flagged',
+        'is_deleted',
+        'is_draft',
+        'is_junk',
+        'is_copied',
+        'is_encrypted',
+        'is_searchable',
+        'is_expired',
+        'has_attachments',
+        'has_attachment',
+        'subject',
+        'body',
+        'text',
+        'headers',
+        'message_id',
+        'search',
+        'q',
+        'since',
+        'before',
+        'min_size',
+        'max_size',
+        'from',
+        'to',
+        'cc',
+        'bcc',
+        'date',
+        'reply-to',
+      ],
+    }),
+    createMessage: createTool({
+      name: 'createMessage',
+      description: 'Create a new message (draft)',
+      method: 'post',
+      path: '/v1/messages',
+    }),
+    getMessage: createTool({
+      name: 'getMessage',
+      description: 'Get a message by ID',
+      method: 'get',
+      path: '/v1/messages/{id}',
+      query: ['eml', 'nodemailer', 'attachments', 'raw'],
+    }),
+    updateMessage: createTool({
+      name: 'updateMessage',
+      description: 'Update a message',
+      method: 'put',
+      path: '/v1/messages/{id}',
+      query: ['eml'],
+    }),
+    deleteMessage: createTool({
+      name: 'deleteMessage',
+      description: 'Delete a message',
+      method: 'delete',
+      path: '/v1/messages/{id}',
+    }),
+
+    //
+    // Folders (IMAP)
+    //
+    listFolders: createTool({
+      name: 'listFolders',
+      description: 'List all folders',
+      method: 'get',
+      path: '/v1/folders',
+      query: ['subscribed'],
+    }),
+    createFolder: createTool({
+      name: 'createFolder',
+      description: 'Create a new folder',
+      method: 'post',
+      path: '/v1/folders',
+    }),
+    getFolder: createTool({
+      name: 'getFolder',
+      description: 'Get a folder by ID',
+      method: 'get',
+      path: '/v1/folders/{id}',
+    }),
+    updateFolder: createTool({
+      name: 'updateFolder',
+      description: 'Update a folder',
+      method: 'put',
+      path: '/v1/folders/{id}',
+    }),
+    deleteFolder: createTool({
+      name: 'deleteFolder',
+      description: 'Delete a folder',
+      method: 'delete',
+      path: '/v1/folders/{id}',
+    }),
+
+    //
+    // Encrypt
+    //
+    encryptRecord: createTool({
+      name: 'encryptRecord',
+      description: 'Encrypt a plaintext Forward Email TXT record',
+      method: 'post',
+      path: '/v1/encrypt',
+    }),
+  };
+
+  return tools;
+};
+
+module.exports = {getTools};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@forwardemail/mcp-server",
+  "description": "Model Context Protocol (MCP) server for Forward Email. Connect AI to your inbox.",
+  "version": "1.0.0",
+  "author": "Forward Email LLC <support@forwardemail.net> (https://forwardemail.net)",
+  "bin": {
+    "mcp-server": "./bin/mcp-server.js"
+  },
+  "bugs": {
+    "url": "https://github.com/forwardemail/mcp-server/issues"
+  },
+  "dependencies": {
+    "axios": "^1.7.2",
+    "cosmiconfig": "^9.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "c8": "^10.1.2",
+    "fixpack": "^4.0.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.2.5",
+    "remark-cli": "^12.0.1",
+    "remark-preset-lint-recommended": "^7.0.1",
+    "xo": "^0.58.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://forwardemail.net/mcp",
+  "keywords": [
+    "ai",
+    "automation",
+    "chatgpt",
+    "claude",
+    "email",
+    "forward-email",
+    "llm",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "license": "BUSL-1.1",
+  "main": "lib/index.js",
+  "prettier": {
+    "useTabs": false,
+    "tabWidth": 2,
+    "singleQuote": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/forwardemail/mcp-server.git"
+  },
+  "types": "lib/index.d.ts",
+  "xo": {
+    "space": 2,
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-module": "off",
+      "import-x/extensions": "off",
+      "n/prefer-global/process": "off"
+    }
+  },
+  "scripts": {
+    "lint": "fixpack && remark . -qfo && xo --fix",
+    "pre-commit": "lint-staged",
+    "pretest": "pnpm run lint",
+    "test": "c8 --reporter=text --reporter=html node --test"
+  }
+}