feat: add Email Plugin with SMTP functionality

- Implemented the Email Plugin for self-hosted Memos instances, providing SMTP email sending capabilities.
- Created configuration structure for SMTP settings with validation.
- Developed message structure for email content with validation and formatting.
- Added synchronous and asynchronous email sending methods.
- Implemented error handling and logging for email sending processes.
- Included tests for client, configuration, and message functionalities to ensure reliability.
- Updated documentation to reflect new features and usage instructions.

Author: johnnyjoygh

plugin/email/README.md

@@ -0,0 +1,143 @@
+package email
+
+import (
+	"crypto/tls"
+	"net/smtp"
+
+	"github.com/pkg/errors"
+)
+
+// Client represents an SMTP email client.
+type Client struct {
+	config *Config
+}
+
+// NewClient creates a new email client with the given configuration.
+func NewClient(config *Config) *Client {
+	return &Client{
+		config: config,
+	}
+}
+
+// validateConfig validates the client configuration.
+func (c *Client) validateConfig() error {
+	if c.config == nil {
+		return errors.New("email configuration is required")
+	}
+	return c.config.Validate()
+}
+
+// createAuth creates an SMTP auth mechanism if credentials are provided.
+func (c *Client) createAuth() smtp.Auth {
+	if c.config.SMTPUsername == "" && c.config.SMTPPassword == "" {
+		return nil
+	}
+	return smtp.PlainAuth("", c.config.SMTPUsername, c.config.SMTPPassword, c.config.SMTPHost)
+}
+
+// createTLSConfig creates a TLS configuration for secure connections.
+func (c *Client) createTLSConfig() *tls.Config {
+	return &tls.Config{
+		ServerName: c.config.SMTPHost,
+		MinVersion: tls.VersionTLS12,
+	}
+}
+
+// Send sends an email message via SMTP.
+func (c *Client) Send(message *Message) error {
+	// Validate configuration
+	if err := c.validateConfig(); err != nil {
+		return errors.Wrap(err, "invalid email configuration")
+	}
+
+	// Validate message
+	if message == nil {
+		return errors.New("message is required")
+	}
+	if err := message.Validate(); err != nil {
+		return errors.Wrap(err, "invalid email message")
+	}
+
+	// Format the message
+	body := message.Format(c.config.FromEmail, c.config.FromName)
+
+	// Get all recipients
+	recipients := message.GetAllRecipients()
+
+	// Create auth
+	auth := c.createAuth()
+
+	// Send based on encryption type
+	if c.config.UseSSL {
+		return c.sendWithSSL(auth, recipients, body)
+	}
+	return c.sendWithTLS(auth, recipients, body)
+}
+
+// sendWithTLS sends email using STARTTLS (port 587).
+func (c *Client) sendWithTLS(auth smtp.Auth, recipients []string, body string) error {
+	serverAddr := c.config.GetServerAddress()
+
+	if c.config.UseTLS {
+		// Use STARTTLS
+		return smtp.SendMail(serverAddr, auth, c.config.FromEmail, recipients, []byte(body))
+	}
+
+	// Send without encryption (not recommended)
+	return smtp.SendMail(serverAddr, auth, c.config.FromEmail, recipients, []byte(body))
+}
+
+// sendWithSSL sends email using SSL/TLS (port 465).
+func (c *Client) sendWithSSL(auth smtp.Auth, recipients []string, body string) error {
+	serverAddr := c.config.GetServerAddress()
+
+	// Create TLS connection
+	tlsConfig := c.createTLSConfig()
+	conn, err := tls.Dial("tcp", serverAddr, tlsConfig)
+	if err != nil {
+		return errors.Wrapf(err, "failed to connect to SMTP server with SSL: %s", serverAddr)
+	}
+	defer conn.Close()
+
+	// Create SMTP client
+	client, err := smtp.NewClient(conn, c.config.SMTPHost)
+	if err != nil {
+		return errors.Wrap(err, "failed to create SMTP client")
+	}
+	defer client.Quit()
+
+	// Authenticate
+	if auth != nil {
+		if err := client.Auth(auth); err != nil {
+			return errors.Wrap(err, "SMTP authentication failed")
+		}
+	}
+
+	// Set sender
+	if err := client.Mail(c.config.FromEmail); err != nil {
+		return errors.Wrap(err, "failed to set sender")
+	}
+
+	// Set recipients
+	for _, recipient := range recipients {
+		if err := client.Rcpt(recipient); err != nil {
+			return errors.Wrapf(err, "failed to set recipient: %s", recipient)
+		}
+	}
+
+	// Send message body
+	writer, err := client.Data()
+	if err != nil {
+		return errors.Wrap(err, "failed to send DATA command")
+	}
+
+	if _, err := writer.Write([]byte(body)); err != nil {
+		return errors.Wrap(err, "failed to write message body")
+	}
+
+	if err := writer.Close(); err != nil {
+		return errors.Wrap(err, "failed to close message writer")
+	}
+
+	return nil
+}

plugin/email/client.go

@@ -0,0 +1,121 @@
+package email
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewClient(t *testing.T) {
+	config := &Config{
+		SMTPHost:     "smtp.example.com",
+		SMTPPort:     587,
+		SMTPUsername: "user@example.com",
+		SMTPPassword: "password",
+		FromEmail:    "noreply@example.com",
+		FromName:     "Test App",
+		UseTLS:       true,
+	}
+
+	client := NewClient(config)
+
+	assert.NotNil(t, client)
+	assert.Equal(t, config, client.config)
+}
+
+func TestClientValidateConfig(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  *Config
+		wantErr bool
+	}{
+		{
+			name: "valid config",
+			config: &Config{
+				SMTPHost:  "smtp.example.com",
+				SMTPPort:  587,
+				FromEmail: "test@example.com",
+			},
+			wantErr: false,
+		},
+		{
+			name:    "nil config",
+			config:  nil,
+			wantErr: true,
+		},
+		{
+			name: "invalid config",
+			config: &Config{
+				SMTPHost: "",
+				SMTPPort: 587,
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := NewClient(tt.config)
+			err := client.validateConfig()
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestClientSendValidation(t *testing.T) {
+	config := &Config{
+		SMTPHost:  "smtp.example.com",
+		SMTPPort:  587,
+		FromEmail: "test@example.com",
+	}
+	client := NewClient(config)
+
+	tests := []struct {
+		name    string
+		message *Message
+		wantErr bool
+	}{
+		{
+			name: "valid message",
+			message: &Message{
+				To:      []string{"recipient@example.com"},
+				Subject: "Test",
+				Body:    "Test body",
+			},
+			wantErr: false, // Will fail on actual send, but passes validation
+		},
+		{
+			name:    "nil message",
+			message: nil,
+			wantErr: true,
+		},
+		{
+			name: "invalid message",
+			message: &Message{
+				To:      []string{},
+				Subject: "Test",
+				Body:    "Test",
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := client.Send(tt.message)
+			// We expect validation errors for invalid messages
+			// For valid messages, we'll get connection errors (which is expected in tests)
+			if tt.wantErr {
+				assert.Error(t, err)
+				// Should fail validation before attempting connection
+				assert.NotContains(t, err.Error(), "dial")
+			}
+			// Note: We don't assert NoError for valid messages because
+			// we don't have a real SMTP server in tests
+		})
+	}
+}

plugin/email/client_test.go

@@ -0,0 +1,47 @@
+package email
+
+import (
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+// Config represents the SMTP configuration for email sending.
+// These settings should be provided by the self-hosted instance administrator.
+type Config struct {
+	// SMTPHost is the SMTP server hostname (e.g., "smtp.gmail.com")
+	SMTPHost string
+	// SMTPPort is the SMTP server port (common: 587 for TLS, 465 for SSL, 25 for unencrypted)
+	SMTPPort int
+	// SMTPUsername is the SMTP authentication username (usually the email address)
+	SMTPUsername string
+	// SMTPPassword is the SMTP authentication password or app-specific password
+	SMTPPassword string
+	// FromEmail is the email address that will appear in the "From" field
+	FromEmail string
+	// FromName is the display name that will appear in the "From" field
+	FromName string
+	// UseTLS enables STARTTLS encryption (recommended for port 587)
+	UseTLS bool
+	// UseSSL enables SSL/TLS encryption (for port 465)
+	UseSSL bool
+}
+
+// Validate checks if the configuration is valid.
+func (c *Config) Validate() error {
+	if c.SMTPHost == "" {
+		return errors.New("SMTP host is required")
+	}
+	if c.SMTPPort <= 0 || c.SMTPPort > 65535 {
+		return errors.New("SMTP port must be between 1 and 65535")
+	}
+	if c.FromEmail == "" {
+		return errors.New("from email is required")
+	}
+	return nil
+}
+
+// GetServerAddress returns the SMTP server address in the format "host:port".
+func (c *Config) GetServerAddress() string {
+	return fmt.Sprintf("%s:%d", c.SMTPHost, c.SMTPPort)
+}

plugin/email/config.go

@@ -0,0 +1,80 @@
+package email
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConfigValidation(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  *Config
+		wantErr bool
+	}{
+		{
+			name: "valid config",
+			config: &Config{
+				SMTPHost:     "smtp.gmail.com",
+				SMTPPort:     587,
+				SMTPUsername: "user@example.com",
+				SMTPPassword: "password",
+				FromEmail:    "noreply@example.com",
+				FromName:     "Memos",
+			},
+			wantErr: false,
+		},
+		{
+			name: "missing host",
+			config: &Config{
+				SMTPPort:     587,
+				SMTPUsername: "user@example.com",
+				SMTPPassword: "password",
+				FromEmail:    "noreply@example.com",
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid port",
+			config: &Config{
+				SMTPHost:     "smtp.gmail.com",
+				SMTPPort:     0,
+				SMTPUsername: "user@example.com",
+				SMTPPassword: "password",
+				FromEmail:    "noreply@example.com",
+			},
+			wantErr: true,
+		},
+		{
+			name: "missing from email",
+			config: &Config{
+				SMTPHost:     "smtp.gmail.com",
+				SMTPPort:     587,
+				SMTPUsername: "user@example.com",
+				SMTPPassword: "password",
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.Validate()
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestConfigGetServerAddress(t *testing.T) {
+	config := &Config{
+		SMTPHost: "smtp.gmail.com",
+		SMTPPort: 587,
+	}
+
+	expected := "smtp.gmail.com:587"
+	assert.Equal(t, expected, config.GetServerAddress())
+}