fix(imap): samme mail blev en ny opgave hver gang, og uddraget var rå MIME

To fejl fra ét skærmbillede.

Markøren stod stille. Den blev sat ud fra uid'en i fetch-svaret, og den kommer
ikke fra alle servere — så next-run læste fra nul hver gang. Den sættes nu ud fra
hvad SØGNINGEN fandt, når kørslen kom hele vejen igennem: så er alt op til det
punkt betragtet, uanset hvad fetch-svaret bar med. En afbrudt kørsel flytter kun
til den sidste, den faktisk lavede en opgave af. Prøven mod hukommelsesserveren
ville aldrig have fanget det, for den svarer altid med uid.

Og uddraget hentede BODY[TEXT], som ved multipart er grænser og dele-hoveder og
det hele — derfor stod der "--=_be71cb39… Content-Transfer-Encoding: 8bit" foran
teksten i hver eneste opgave. Nu hentes hele beskeden og MIME-strukturen gås
igennem: text/plain foretrækkes, HTML er reserven med mærkerne pillet af. Groft,
for det er linjen under en overskrift og ikke en gengivelsesmotor.

Multipart-prøven er sat på prøve: med den gamle hentning fejler den med præcis
den tekst, skærmbilledet viste.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

internal/imap/imap.go

@@ -16,15 +16,18 @@
 package imap
 
 import (
+	"bytes"
 	"crypto/tls"
 	"crypto/x509"
 	"fmt"
+	"io"
 	"net"
 	"strings"
 	"time"
 
 	"github.com/emersion/go-imap/v2"
 	"github.com/emersion/go-imap/v2/imapclient"
+	"github.com/emersion/go-message"
 )
 
 // Message is one mail, reduced to what a task needs.
@@ -108,9 +111,13 @@ func (c *Client) Close() error {
 // that consumed it would be taking something away. Flagging a mail is a deliberate
 // act with no other meaning, which is exactly what is wanted — the same reason the
 // Gmail side reads stars.
-func (c *Client) Since(uid uint32, limit int) ([]Message, error) {
+// The second return is the highest uid the search considered. A caller that got
+// through every message can move its marker to that, and then it does not matter
+// whether the server put a uid in each fetch reply — which some do not, and which
+// is how the same mail became a task again on every run.
+func (c *Client) Since(uid uint32, limit int) ([]Message, uint32, error) {
 	if _, err := c.c.Select(c.folder, &imap.SelectOptions{ReadOnly: true}).Wait(); err != nil {
-		return nil, fmt.Errorf("open %s: %w", c.folder, err)
+		return nil, 0, fmt.Errorf("open %s: %w", c.folder, err)
 	}
 
 	// From uid+1 to the end. A mailbox with nothing new answers with no uids
@@ -124,12 +131,12 @@ func (c *Client) Since(uid uint32, limit int) ([]Message, error) {
 	}
 	found, err := c.c.UIDSearch(criteria, nil).Wait()
 	if err != nil {
-		return nil, fmt.Errorf("search %s: %w", c.folder, err)
+		return nil, 0, fmt.Errorf("search %s: %w", c.folder, err)
 	}
 
 	uids := found.AllUIDs()
 	if len(uids) == 0 {
-		return nil, nil
+		return nil, uid, nil
 	}
 	if limit > 0 && len(uids) > limit {
 		// The newest ones. A mailbox flagged over years would otherwise make the
@@ -139,29 +146,51 @@ func (c *Client) Since(uid uint32, limit int) ([]Message, error) {
 
 	want := imap.UIDSetNum(uids...)
 	fetch := &imap.FetchOptions{
-		Envelope:    true,
-		UID:         true,
-		BodySection: []*imap.FetchItemBodySection{{Specifier: imap.PartSpecifierText, Peek: true}},
+		Envelope: true,
+		UID:      true,
+		// The whole message, headers included, so the MIME structure can be walked.
+		// TEXT alone gives the body as bytes — boundaries and part headers and all —
+		// which is what put "--=_be71cb39… Content-Transfer-Encoding: 8bit" at the
+		// front of every task made from a multipart mail.
+		BodySection: []*imap.FetchItemBodySection{{Peek: true}},
 	}
+	var highest uint32
+	for _, u := range uids {
+		if uint32(u) > highest {
+			highest = uint32(u)
+		}
+	}
+
 	msgs, err := c.c.Fetch(want, fetch).Collect()
 	if err != nil {
-		return nil, fmt.Errorf("fetch from %s: %w", c.folder, err)
+		return nil, 0, fmt.Errorf("fetch from %s: %w", c.folder, err)
 	}
 
 	out := make([]Message, 0, len(msgs))
-	for _, m := range msgs {
+	for i, m := range msgs {
 		if m.Envelope == nil {
 			continue
 		}
+
+		// The uid comes from the search when the fetch reply does not carry one.
+		// A missing uid is not cosmetic: it is the marker the next run starts from,
+		// and a marker stuck at zero makes every message arrive again on every run.
+		// That is what happened against a real server while the tests stayed green,
+		// because the server they run against always answers with it.
+		msgUID := uint32(m.UID)
+		if msgUID == 0 && i < len(uids) {
+			msgUID = uint32(uids[i])
+		}
+
 		out = append(out, Message{
-			UID:     uint32(m.UID),
+			UID:     msgUID,
 			From:    address(m.Envelope.From),
 			Subject: strings.TrimSpace(m.Envelope.Subject),
 			Snippet: snippet(m),
 			Date:    m.Envelope.Date,
 		})
 	}
-	return out, nil
+	return out, highest, nil
 }
 
 // address renders the first sender as "Name <addr>", or just the address.
@@ -177,23 +206,92 @@ func address(list []imap.Address) string {
 	return a.Name + " <" + addr + ">"
 }
 
-// snippet is the first readable line or so of the body.
+// snippet is the first readable text in the mail.
 //
-// No MIME walk and no HTML stripping yet: this is what shows under a task's title,
-// and a wrong-but-short line is a smaller problem than a parser that has to be
-// right about every mail ever sent. The full mail stays where it is.
+// It walks the MIME structure rather than taking the body as bytes. text/plain is
+// preferred and HTML is the fallback with its tags stripped — crudely, because
+// this is the line under a task's title and not a rendering engine. The mail
+// itself stays where it is.
 const snippetLimit = 400
 
 func snippet(m *imapclient.FetchMessageBuffer) string {
 	for _, body := range m.BodySection {
-		text := strings.TrimSpace(string(body.Bytes))
-		if text == "" {
-			continue
+		if text := readable(body.Bytes); text != "" {
+			return cut(text)
 		}
-		if len(text) > snippetLimit {
-			text = text[:snippetLimit] + "…"
-		}
-		return text
 	}
 	return ""
 }
+
+func readable(raw []byte) string {
+	entity, err := message.Read(bytes.NewReader(raw))
+	if err != nil {
+		// Not something this parser recognises. The raw bytes read badly but read,
+		// and a mail is not worth losing over its own headers.
+		return strings.TrimSpace(string(raw))
+	}
+	return strings.TrimSpace(fromEntity(entity, 0))
+}
+
+// fromEntity descends into a multipart mail. The depth guard is for the mail that
+// nests parts inside parts inside parts — rare, and cheaper to bound than to trust.
+func fromEntity(entity *message.Entity, depth int) string {
+	if depth > 4 {
+		return ""
+	}
+
+	if parts := entity.MultipartReader(); parts != nil {
+		var html string
+		for {
+			part, err := parts.NextPart()
+			if err != nil {
+				break
+			}
+			if text := fromEntity(part, depth+1); text != "" {
+				kind, _, _ := part.Header.ContentType()
+				if kind != "text/html" {
+					return text
+				}
+				if html == "" {
+					html = text
+				}
+			}
+		}
+		return html
+	}
+
+	body, _ := io.ReadAll(entity.Body)
+	kind, _, _ := entity.Header.ContentType()
+	if kind == "text/html" {
+		return stripTags(string(body))
+	}
+	return strings.TrimSpace(string(body))
+}
+
+// stripTags removes markup without pretending to understand it. Enough for one
+// line of preview, and honest about being no more than that.
+func stripTags(html string) string {
+	var b strings.Builder
+	depth := 0
+	for _, r := range html {
+		switch {
+		case r == '<':
+			depth++
+		case r == '>':
+			if depth > 0 {
+				depth--
+			}
+		case depth == 0:
+			b.WriteRune(r)
+		}
+	}
+	return strings.Join(strings.Fields(b.String()), " ")
+}
+
+func cut(text string) string {
+	runes := []rune(text)
+	if len(runes) > snippetLimit {
+		return string(runes[:snippetLimit]) + "…"
+	}
+	return text
+}