feat: Support many recipients, cc and bcc (#11)

* feat: Support many recipients, cc and bcc

* Add testcase

Author: Wh1isper

mcp_email_server/app.py

@@ -61,8 +61,32 @@ async def page_email(
     )
 
 
-@mcp.tool()
-async def send_email(account_name: str, recipient: str, subject: str, body: str) -> None:
+@mcp.tool(
+    description="Send an email using the specified account. Recipient should be a list of email addresses.",
+)
+async def send_email(
+    account_name: str,
+    recipients: list[str],
+    subject: str,
+    body: str,
+    cc: list[str] | None = None,
+    bcc: list[str] | None = None,
+) -> None:
     handler = dispatch_handler(account_name)
-    await handler.send_email(recipient, subject, body)
+    await handler.send_email(recipients, subject, body, cc, bcc)
     return
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(
+        send_email(**{
+            "account_name": "jizhongsheng957@gmail.com",
+            "recipients": ["jizhongsheng957@gmail.com"],
+            "subject": "问候",
+            "body": "你好",
+            "cc": ["9573586@qq.com"],
+            "bcc": ["jzs9573586@qq.com"],
+        })
+    )

mcp_email_server/emails/__init__.py

@@ -25,7 +25,9 @@ async def get_emails(
         """
 
     @abc.abstractmethod
-    async def send_email(self, recipient: str, subject: str, body: str) -> None:
+    async def send_email(
+        self, recipients: list[str], subject: str, body: str, cc: list[str] | None = None, bcc: list[str] | None = None
+    ) -> None:
         """
         Send email
         """

mcp_email_server/emails/classic.py

@@ -222,11 +222,20 @@ async def get_email_count(
             except Exception as e:
                 logger.info(f"Error during logout: {e}")
 
-    async def send_email(self, recipient: str, subject: str, body: str):
+    async def send_email(
+        self, recipients: list[str], subject: str, body: str, cc: list[str] | None = None, bcc: list[str] | None = None
+    ):
         msg = MIMEText(body)
         msg["Subject"] = subject
         msg["From"] = self.sender
-        msg["To"] = recipient
+        msg["To"] = ", ".join(recipients)
+
+        # Add CC header if provided (visible to recipients)
+        if cc:
+            msg["Cc"] = ", ".join(cc)
+
+        # Note: BCC recipients are not added to headers (they remain hidden)
+        # but will be included in the actual recipients for SMTP delivery
 
         async with aiosmtplib.SMTP(
             hostname=self.email_server.host,
@@ -235,7 +244,15 @@ async def send_email(self, recipient: str, subject: str, body: str):
             use_tls=self.smtp_use_tls,
         ) as smtp:
             await smtp.login(self.email_server.user_name, self.email_server.password)
-            await smtp.send_message(msg)
+
+            # Create a combined list of all recipients for delivery
+            all_recipients = recipients.copy()
+            if cc:
+                all_recipients.extend(cc)
+            if bcc:
+                all_recipients.extend(bcc)
+
+            await smtp.send_message(msg, recipients=all_recipients)
 
 
 class ClassicEmailHandler(EmailHandler):
@@ -277,5 +294,7 @@ async def get_emails(
             total=total,
         )
 
-    async def send_email(self, recipient: str, subject: str, body: str) -> None:
-        await self.outgoing_client.send_email(recipient, subject, body)
+    async def send_email(
+        self, recipients: list[str], subject: str, body: str, cc: list[str] | None = None, bcc: list[str] | None = None
+    ) -> None:
+        await self.outgoing_client.send_email(recipients, subject, body, cc, bcc)

mcp_email_server/emails/dispatcher.py

@@ -16,3 +16,5 @@ def dispatch_handler(account_name: str) -> EmailHandler:
         raise NotImplementedError
     if isinstance(account, EmailSettings):
         return ClassicEmailHandler(account)
+
+    raise ValueError(f"Account {account_name} not found, available accounts: {settings.get_accounts()}")

pyproject.toml

@@ -40,6 +40,7 @@ Documentation = "https://ai-zerolab.github.io/mcp-email-server/"
 [dependency-groups]
 dev = [
     "pytest>=7.2.0",
+    "pytest-asyncio>=0.25.3",
     "pre-commit>=2.20.0",
     "tox-uv>=1.11.3",
     "deptry>=0.22.0",
@@ -111,7 +112,7 @@ ignore = [
 ]
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*" = ["S101"]
+"tests/*" = ["S101", "S106", "SIM117"]
 
 [tool.ruff.format]
 preview = true

pytest.ini

@@ -0,0 +1,4 @@
+# pytest.ini
+[pytest]
+asyncio_mode = auto
+# asyncio_default_fixture_loop_scope =

tests/conftest.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
+import asyncio
 import os
+from datetime import datetime
 from pathlib import Path
+from unittest.mock import AsyncMock
 
 import pytest
 
+from mcp_email_server.config import EmailServer, EmailSettings, ProviderSettings, delete_settings
+
 _HERE = Path(__file__).resolve().parent
 
 os.environ["MCP_EMAIL_SERVER_CONFIG_PATH"] = (_HERE / "config.toml").as_posix()
@@ -13,7 +18,90 @@
 
 @pytest.fixture(autouse=True)
 def patch_env(monkeypatch: pytest.MonkeyPatch, tmp_path: pytest.TempPathFactory):
-    from mcp_email_server.config import delete_settings
-
     delete_settings()
     yield
+
+
+@pytest.fixture
+def email_server():
+    """Fixture for a test EmailServer."""
+    return EmailServer(
+        user_name="test_user",
+        password="test_password",
+        host="test.example.com",
+        port=993,
+        use_ssl=True,
+    )
+
+
+@pytest.fixture
+def email_settings():
+    """Fixture for test EmailSettings."""
+    return EmailSettings(
+        account_name="test_account",
+        full_name="Test User",
+        email_address="test@example.com",
+        incoming=EmailServer(
+            user_name="test_user",
+            password="test_password",
+            host="imap.example.com",
+            port=993,
+            use_ssl=True,
+        ),
+        outgoing=EmailServer(
+            user_name="test_user",
+            password="test_password",
+            host="smtp.example.com",
+            port=465,
+            use_ssl=True,
+        ),
+    )
+
+
+@pytest.fixture
+def provider_settings():
+    """Fixture for test ProviderSettings."""
+    return ProviderSettings(
+        account_name="test_provider",
+        provider_name="test_provider",
+        api_key="test_api_key",
+    )
+
+
+@pytest.fixture
+def mock_imap():
+    """Fixture for a mocked IMAP client."""
+    mock_imap = AsyncMock()
+    mock_imap._client_task = asyncio.Future()
+    mock_imap._client_task.set_result(None)
+    mock_imap.wait_hello_from_server = AsyncMock()
+    mock_imap.login = AsyncMock()
+    mock_imap.select = AsyncMock()
+    mock_imap.search = AsyncMock(return_value=(None, [b"1 2 3"]))
+    mock_imap.fetch = AsyncMock(return_value=(None, [b"HEADER", bytearray(b"EMAIL CONTENT")]))
+    mock_imap.logout = AsyncMock()
+    return mock_imap
+
+
+@pytest.fixture
+def mock_smtp():
+    """Fixture for a mocked SMTP client."""
+    mock_smtp = AsyncMock()
+    mock_smtp.__aenter__.return_value = mock_smtp
+    mock_smtp.__aexit__.return_value = None
+    mock_smtp.login = AsyncMock()
+    mock_smtp.send_message = AsyncMock()
+    return mock_smtp
+
+
+@pytest.fixture
+def sample_email_data():
+    """Fixture for sample email data."""
+    now = datetime.now()
+    return {
+        "subject": "Test Subject",
+        "from": "sender@example.com",
+        "body": "Test Body",
+        "date": now,
+        "attachments": ["attachment.pdf"],
+    }

tests/test_classic_handler.py

@@ -0,0 +1,137 @@
+from datetime import datetime
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from mcp_email_server.config import EmailServer, EmailSettings
+from mcp_email_server.emails.classic import ClassicEmailHandler, EmailClient
+from mcp_email_server.emails.models import EmailData, EmailPageResponse
+
+
+@pytest.fixture
+def email_settings():
+    return EmailSettings(
+        account_name="test_account",
+        full_name="Test User",
+        email_address="test@example.com",
+        incoming=EmailServer(
+            user_name="test_user",
+            password="test_password",
+            host="imap.example.com",
+            port=993,
+            use_ssl=True,
+        ),
+        outgoing=EmailServer(
+            user_name="test_user",
+            password="test_password",
+            host="smtp.example.com",
+            port=465,
+            use_ssl=True,
+        ),
+    )
+
+
+@pytest.fixture
+def classic_handler(email_settings):
+    return ClassicEmailHandler(email_settings)
+
+
+class TestClassicEmailHandler:
+    def test_init(self, email_settings):
+        """Test initialization of ClassicEmailHandler."""
+        handler = ClassicEmailHandler(email_settings)
+
+        assert handler.email_settings == email_settings
+        assert isinstance(handler.incoming_client, EmailClient)
+        assert isinstance(handler.outgoing_client, EmailClient)
+
+        # Check that clients are initialized correctly
+        assert handler.incoming_client.email_server == email_settings.incoming
+        assert handler.outgoing_client.email_server == email_settings.outgoing
+        assert handler.outgoing_client.sender == f"{email_settings.full_name} <{email_settings.email_address}>"
+
+    @pytest.mark.asyncio
+    async def test_get_emails(self, classic_handler):
+        """Test get_emails method."""
+        # Create test data
+        now = datetime.now()
+        email_data = {
+            "subject": "Test Subject",
+            "from": "sender@example.com",
+            "body": "Test Body",
+            "date": now,
+            "attachments": [],
+        }
+
+        # Mock the get_emails_stream method to yield our test data
+        mock_stream = AsyncMock()
+        mock_stream.__aiter__.return_value = [email_data]
+
+        # Mock the get_email_count method
+        mock_count = AsyncMock(return_value=1)
+
+        # Apply the mocks
+        with patch.object(classic_handler.incoming_client, "get_emails_stream", return_value=mock_stream):
+            with patch.object(classic_handler.incoming_client, "get_email_count", mock_count):
+                # Call the method
+                result = await classic_handler.get_emails(
+                    page=1,
+                    page_size=10,
+                    before=now,
+                    since=None,
+                    subject="Test",
+                    body=None,
+                    text=None,
+                    from_address="sender@example.com",
+                    to_address=None,
+                )
+
+                # Verify the result
+                assert isinstance(result, EmailPageResponse)
+                assert result.page == 1
+                assert result.page_size == 10
+                assert result.before == now
+                assert result.since is None
+                assert result.subject == "Test"
+                assert result.body is None
+                assert result.text is None
+                assert len(result.emails) == 1
+                assert isinstance(result.emails[0], EmailData)
+                assert result.emails[0].subject == "Test Subject"
+                assert result.emails[0].sender == "sender@example.com"
+                assert result.emails[0].body == "Test Body"
+                assert result.emails[0].date == now
+                assert result.emails[0].attachments == []
+                assert result.total == 1
+
+                # Verify the client methods were called correctly
+                classic_handler.incoming_client.get_emails_stream.assert_called_once_with(
+                    1, 10, now, None, "Test", None, None, "sender@example.com", None
+                )
+                mock_count.assert_called_once_with(now, None, "Test", None, None, "sender@example.com", None)
+
+    @pytest.mark.asyncio
+    async def test_send_email(self, classic_handler):
+        """Test send_email method."""
+        # Mock the outgoing_client.send_email method
+        mock_send = AsyncMock()
+
+        # Apply the mock
+        with patch.object(classic_handler.outgoing_client, "send_email", mock_send):
+            # Call the method
+            await classic_handler.send_email(
+                recipients=["recipient@example.com"],
+                subject="Test Subject",
+                body="Test Body",
+                cc=["cc@example.com"],
+                bcc=["bcc@example.com"],
+            )
+
+            # Verify the client method was called correctly
+            mock_send.assert_called_once_with(
+                ["recipient@example.com"],
+                "Test Subject",
+                "Test Body",
+                ["cc@example.com"],
+                ["bcc@example.com"],
+            )