zwischenstand

internal/agents/tool/email/client.go

@@ -3,7 +3,12 @@ package email
 
 import (
 	"crypto/tls"
+	"encoding/base64"
 	"fmt"
+	"log/slog"
+	"mime/quotedprintable"
+	"strings"
+	"time"
 
 	imap "github.com/emersion/go-imap/v2"
 	"github.com/emersion/go-imap/v2/imapclient"
@@ -18,15 +23,43 @@ type Message struct {
 	Date    string
 }
 
-// Client wraps die IMAP-Verbindung.
-type Client struct {
-	c *imapclient.Client
+// SelectMessage koppelt eine Message mit ihrer IMAP-Sequenznummer für UI-Zwecke.
+type SelectMessage struct {
+	Message
+	SeqNum uint32
+	Unread bool // true = \Seen flag nicht gesetzt
 }
 
-// Connect öffnet eine IMAP-Verbindung.
+// MessageWithBody repräsentiert eine Email mit Text-Inhalt (für Datenbankimport).
+type MessageWithBody struct {
+	Message
+	Body string
+}
+
+// Client wraps die IMAP-Verbindung.
+type Client struct {
+	c      *imapclient.Client
+	folder string // INBOX-Ordner (leer = "INBOX")
+}
+
+// Connect öffnet eine IMAP-Verbindung mit dem Legacy-Email-Block aus der Config.
 func Connect() (*Client, error) {
 	cfg := config.Cfg.Email
-	addr := fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
+	acc := config.EmailAccount{
+		Host:     cfg.Host,
+		Port:     cfg.Port,
+		User:     cfg.User,
+		Password: cfg.Password,
+		TLS:      cfg.TLS,
+		StartTLS: cfg.StartTLS,
+		Folder:   cfg.Folder,
+	}
+	return ConnectAccount(acc)
+}
+
+// ConnectAccount öffnet eine IMAP-Verbindung für einen bestimmten EmailAccount.
+func ConnectAccount(acc config.EmailAccount) (*Client, error) {
+	addr := fmt.Sprintf("%s:%d", acc.Host, acc.Port)
 
 	var (
 		c   *imapclient.Client
@@ -34,11 +67,11 @@ func Connect() (*Client, error) {
 	)
 
 	switch {
-	case cfg.TLS:
-		tlsCfg := &tls.Config{ServerName: cfg.Host}
+	case acc.TLS:
+		tlsCfg := &tls.Config{ServerName: acc.Host}
 		c, err = imapclient.DialTLS(addr, &imapclient.Options{TLSConfig: tlsCfg})
-	case cfg.StartTLS:
-		tlsCfg := &tls.Config{ServerName: cfg.Host}
+	case acc.StartTLS:
+		tlsCfg := &tls.Config{ServerName: acc.Host}
 		c, err = imapclient.DialStartTLS(addr, &imapclient.Options{TLSConfig: tlsCfg})
 	default:
 		c, err = imapclient.DialInsecure(addr, nil)
@@ -47,12 +80,12 @@ func Connect() (*Client, error) {
 		return nil, fmt.Errorf("IMAP verbinden: %w", err)
 	}
 
-	if err := c.Login(cfg.User, cfg.Password).Wait(); err != nil {
+	if err := c.Login(acc.User, acc.Password).Wait(); err != nil {
 		c.Close()
 		return nil, fmt.Errorf("IMAP login: %w", err)
 	}
 
-	return &Client{c: c}, nil
+	return &Client{c: c, folder: acc.Folder}, nil
 }
 
 // Close schließt die Verbindung.
@@ -61,9 +94,28 @@ func (cl *Client) Close() {
 	cl.c.Close()
 }
 
+// EnsureFolder legt einen IMAP-Ordner an falls er nicht existiert.
+// Strato-kompatibel: ignoriert alle "already exists"-Varianten.
+func (cl *Client) EnsureFolder(folder string) error {
+	err := cl.c.Create(folder, nil).Wait()
+	if err == nil {
+		slog.Info("IMAP: Ordner angelegt", "ordner", folder)
+		return nil
+	}
+	errLower := strings.ToLower(err.Error())
+	if strings.Contains(errLower, "already exists") ||
+		strings.Contains(errLower, "alreadyexists") ||
+		strings.Contains(errLower, "mailbox exists") ||
+		strings.Contains(errLower, "exists") {
+		return nil // Ordner existiert bereits — kein Fehler
+	}
+	slog.Error("IMAP: Ordner anlegen fehlgeschlagen", "ordner", folder, "fehler", err)
+	return fmt.Errorf("IMAP create folder %s: %w", folder, err)
+}
+
 // FetchRecent holt die letzten n Emails (Envelope-Daten, kein Body).
 func (cl *Client) FetchRecent(n uint32) ([]Message, error) {
-	folder := config.Cfg.Email.Folder
+	folder := cl.folder
 	if folder == "" {
 		folder = "INBOX"
 	}
@@ -94,7 +146,7 @@ func (cl *Client) FetchRecent(n uint32) ([]Message, error) {
 
 // FetchUnread holt ungelesene Emails (Envelope-Daten, kein Body).
 func (cl *Client) FetchUnread() ([]Message, error) {
-	folder := config.Cfg.Email.Folder
+	folder := cl.folder
 	if folder == "" {
 		folder = "INBOX"
 	}
@@ -129,7 +181,7 @@ func (cl *Client) FetchUnread() ([]Message, error) {
 // FetchUnreadSeqNums holt ungelesene Emails und gibt zusätzlich die Sequenznummern zurück.
 // Selektiert den Ordner im Lese-Schreib-Modus (für nachfolgendes Verschieben).
 func (cl *Client) FetchUnreadSeqNums() ([]Message, []uint32, error) {
-	folder := config.Cfg.Email.Folder
+	folder := cl.folder
 	if folder == "" {
 		folder = "INBOX"
 	}
@@ -172,6 +224,328 @@ func (cl *Client) MoveMessages(seqNums []uint32, destFolder string) error {
 	return nil
 }
 
+// FetchUnreadForSelect gibt ungelesene Emails mit ihren Sequenznummern zurück.
+// Selektiert den Ordner im Lese-Schreib-Modus (für nachfolgendes Verschieben).
+func (cl *Client) FetchUnreadForSelect() ([]SelectMessage, error) {
+	folder := cl.folder
+	if folder == "" {
+		folder = "INBOX"
+	}
+
+	if _, err := cl.c.Select(folder, nil).Wait(); err != nil {
+		return nil, fmt.Errorf("IMAP select: %w", err)
+	}
+
+	searchData, err := cl.c.Search(&imap.SearchCriteria{
+		NotFlag: []imap.Flag{imap.FlagSeen},
+	}, nil).Wait()
+	if err != nil {
+		return nil, fmt.Errorf("IMAP search: %w", err)
+	}
+
+	seqNums := searchData.AllSeqNums()
+	if len(seqNums) == 0 {
+		return nil, nil
+	}
+
+	var seqSet imap.SeqSet
+	seqSet.AddNum(seqNums...)
+
+	rawMsgs, err := cl.c.Fetch(seqSet, &imap.FetchOptions{Envelope: true}).Collect()
+	if err != nil {
+		return nil, fmt.Errorf("IMAP fetch: %w", err)
+	}
+
+	seqToMsg := make(map[uint32]*imapclient.FetchMessageBuffer, len(rawMsgs))
+	for _, m := range rawMsgs {
+		if m.Envelope != nil {
+			seqToMsg[m.SeqNum] = m
+		}
+	}
+
+	result := make([]SelectMessage, 0, len(seqNums))
+	for _, sn := range seqNums {
+		m, ok := seqToMsg[sn]
+		if !ok {
+			continue
+		}
+		result = append(result, SelectMessage{
+			Message: parseMessage(m),
+			SeqNum:  sn,
+			Unread:  true,
+		})
+	}
+	return result, nil
+}
+
+// FetchRecentForSelect gibt die letzten n Emails mit Sequenznummern und Unread-Status zurück.
+// Selektiert den Ordner im Lese-Schreib-Modus (für nachfolgendes Verschieben).
+func (cl *Client) FetchRecentForSelect(n uint32) ([]SelectMessage, error) {
+	folder := cl.folder
+	if folder == "" {
+		folder = "INBOX"
+	}
+
+	selectData, err := cl.c.Select(folder, nil).Wait()
+	if err != nil {
+		return nil, fmt.Errorf("IMAP select: %w", err)
+	}
+	if selectData.NumMessages == 0 {
+		return nil, nil
+	}
+
+	start := uint32(1)
+	if selectData.NumMessages > n {
+		start = selectData.NumMessages - n + 1
+	}
+
+	var seqSet imap.SeqSet
+	seqSet.AddRange(start, selectData.NumMessages)
+
+	rawMsgs, err := cl.c.Fetch(seqSet, &imap.FetchOptions{Envelope: true, Flags: true}).Collect()
+	if err != nil {
+		return nil, fmt.Errorf("IMAP fetch: %w", err)
+	}
+
+	result := make([]SelectMessage, 0, len(rawMsgs))
+	for _, m := range rawMsgs {
+		if m.Envelope == nil {
+			continue
+		}
+		unread := true
+		for _, f := range m.Flags {
+			if f == imap.FlagSeen {
+				unread = false
+				break
+			}
+		}
+		result = append(result, SelectMessage{
+			Message: parseMessage(m),
+			SeqNum:  m.SeqNum,
+			Unread:  unread,
+		})
+	}
+	return result, nil
+}
+
+// MoveOldMessages verschiebt alle Emails im Ordner, die älter als olderThanDays Tage sind, nach destFolder.
+// Gibt die Anzahl verschobener Nachrichten zurück. olderThanDays <= 0 ist ein No-op.
+func (cl *Client) MoveOldMessages(folder, destFolder string, olderThanDays int) (int, error) {
+	if olderThanDays <= 0 {
+		return 0, nil
+	}
+	if folder == "" {
+		folder = "INBOX"
+	}
+
+	cutoff := time.Now().AddDate(0, 0, -olderThanDays).Truncate(24 * time.Hour)
+
+	if _, err := cl.c.Select(folder, nil).Wait(); err != nil {
+		return 0, fmt.Errorf("IMAP select %s: %w", folder, err)
+	}
+
+	searchData, err := cl.c.Search(&imap.SearchCriteria{Before: cutoff}, nil).Wait()
+	if err != nil {
+		return 0, fmt.Errorf("IMAP search: %w", err)
+	}
+
+	seqNums := searchData.AllSeqNums()
+	if len(seqNums) == 0 {
+		return 0, nil
+	}
+
+	var seqSet imap.SeqSet
+	seqSet.AddNum(seqNums...)
+
+	if _, err := cl.c.Move(seqSet, destFolder).Wait(); err != nil {
+		return 0, fmt.Errorf("IMAP move: %w", err)
+	}
+
+	return len(seqNums), nil
+}
+
+// MoveSpecificMessages selektiert den Inbox-Ordner und verschiebt die angegebenen Sequenznummern.
+func (cl *Client) MoveSpecificMessages(seqNums []uint32, destFolder string) error {
+	folder := cl.folder
+	if folder == "" {
+		folder = "INBOX"
+	}
+	if _, err := cl.c.Select(folder, nil).Wait(); err != nil {
+		return fmt.Errorf("IMAP select: %w", err)
+	}
+	return cl.MoveMessages(seqNums, destFolder)
+}
+
+// CleanupOldEmails löscht Emails im Ordner, die älter als retentionDays sind.
+// Gibt die Anzahl gelöschter Nachrichten zurück. retentionDays <= 0 ist ein No-op.
+func (cl *Client) CleanupOldEmails(folder string, retentionDays int) (int, error) {
+	if retentionDays <= 0 {
+		return 0, nil
+	}
+	if folder == "" {
+		folder = "INBOX"
+	}
+
+	cutoff := time.Now().AddDate(0, 0, -retentionDays).Truncate(24 * time.Hour)
+
+	if _, err := cl.c.Select(folder, nil).Wait(); err != nil {
+		return 0, fmt.Errorf("IMAP select %s: %w", folder, err)
+	}
+
+	searchData, err := cl.c.Search(&imap.SearchCriteria{Before: cutoff}, nil).Wait()
+	if err != nil {
+		return 0, fmt.Errorf("IMAP search: %w", err)
+	}
+
+	seqNums := searchData.AllSeqNums()
+	if len(seqNums) == 0 {
+		return 0, nil
+	}
+
+	var seqSet imap.SeqSet
+	seqSet.AddNum(seqNums...)
+
+	storeFlags := &imap.StoreFlags{
+		Op:     imap.StoreFlagsAdd,
+		Silent: true,
+		Flags:  []imap.Flag{imap.FlagDeleted},
+	}
+	if _, err := cl.c.Store(seqSet, storeFlags, nil).Collect(); err != nil {
+		return 0, fmt.Errorf("IMAP store flags: %w", err)
+	}
+
+	if _, err := cl.c.Expunge().Collect(); err != nil {
+		return 0, fmt.Errorf("IMAP expunge: %w", err)
+	}
+
+	return len(seqNums), nil
+}
+
+// FetchWithBody holt bis zu n Emails aus dem angegebenen Ordner mit Text-Body.
+// Emails werden in Batches von 50 gefetcht um den IMAP-Server nicht zu überlasten.
+func (cl *Client) FetchWithBody(folder string, n uint32) ([]MessageWithBody, error) {
+	if folder == "" {
+		folder = "INBOX"
+	}
+
+	selectData, err := cl.c.Select(folder, &imap.SelectOptions{ReadOnly: true}).Wait()
+	if err != nil {
+		return nil, fmt.Errorf("IMAP select %s: %w", folder, err)
+	}
+	if selectData.NumMessages == 0 {
+		return nil, nil
+	}
+
+	// Letzte n Nachrichten
+	total := selectData.NumMessages
+	start := uint32(1)
+	if total > n {
+		start = total - n + 1
+	}
+
+	bodySec := &imap.FetchItemBodySection{Specifier: imap.PartSpecifierText}
+	hdrSec := &imap.FetchItemBodySection{Specifier: imap.PartSpecifierHeader}
+
+	var result []MessageWithBody
+	batchSize := uint32(50)
+
+	for i := start; i <= total; i += batchSize {
+		end := i + batchSize - 1
+		if end > total {
+			end = total
+		}
+		var seqSet imap.SeqSet
+		seqSet.AddRange(i, end)
+
+		msgs, err := cl.c.Fetch(seqSet, &imap.FetchOptions{
+			Envelope:    true,
+			BodySection: []*imap.FetchItemBodySection{bodySec, hdrSec},
+		}).Collect()
+		if err != nil {
+			return nil, fmt.Errorf("IMAP fetch batch %d-%d: %w", i, end, err)
+		}
+
+		for _, msg := range msgs {
+			if msg.Envelope == nil {
+				continue
+			}
+			m := MessageWithBody{Message: parseMessage(msg)}
+
+			// Content-Transfer-Encoding aus Header lesen
+			enc := ""
+			if hdr := msg.FindBodySection(hdrSec); hdr != nil {
+				for _, line := range strings.Split(string(hdr), "\n") {
+					if strings.HasPrefix(strings.ToLower(line), "content-transfer-encoding:") {
+						enc = strings.TrimSpace(strings.ToLower(strings.SplitN(line, ":", 2)[1]))
+					}
+				}
+			}
+
+			if body := msg.FindBodySection(bodySec); body != nil {
+				m.Body = decodeBody(body, enc)
+			}
+			result = append(result, m)
+		}
+	}
+	return result, nil
+}
+
+// decodeBody dekodiert einen Email-Body je nach Content-Transfer-Encoding.
+func decodeBody(raw []byte, enc string) string {
+	var text string
+	switch enc {
+	case "base64":
+		cleaned := strings.ReplaceAll(strings.TrimSpace(string(raw)), "\r\n", "")
+		if decoded, err := base64.StdEncoding.DecodeString(cleaned); err == nil {
+			text = string(decoded)
+		} else if decoded, err := base64.RawStdEncoding.DecodeString(cleaned); err == nil {
+			text = string(decoded)
+		} else {
+			text = string(raw) // Fallback: roh
+		}
+	case "quoted-printable":
+		r := quotedprintable.NewReader(strings.NewReader(string(raw)))
+		if buf := new(strings.Builder); true {
+			buf.Grow(len(raw))
+			tmp := make([]byte, 4096)
+			for {
+				n, err := r.Read(tmp)
+				buf.Write(tmp[:n])
+				if err != nil {
+					break
+				}
+			}
+			text = buf.String()
+		}
+	default:
+		text = string(raw)
+	}
+
+	// Kürzen auf max 2000 Zeichen
+	text = strings.TrimSpace(text)
+	if len(text) > 2000 {
+		text = text[:2000]
+	}
+	return text
+}
+
+// parseMessage extrahiert eine Message aus einem FetchMessageBuffer.
+func parseMessage(msg *imapclient.FetchMessageBuffer) Message {
+	m := Message{
+		Subject: msg.Envelope.Subject,
+		Date:    msg.Envelope.Date.Format("2006-01-02 15:04"),
+	}
+	if len(msg.Envelope.From) > 0 {
+		addr := msg.Envelope.From[0]
+		if addr.Name != "" {
+			m.From = fmt.Sprintf("%s <%s@%s>", addr.Name, addr.Mailbox, addr.Host)
+		} else {
+			m.From = fmt.Sprintf("%s@%s", addr.Mailbox, addr.Host)
+		}
+	}
+	return m
+}
+
 func parseMessages(msgs []*imapclient.FetchMessageBuffer) []Message {
 	result := make([]Message, 0, len(msgs))
 	for _, msg := range msgs {