feat: markdown for html bodies (#1213)

## What?

Threads MIME type detection from the fetch layer through to rendering.
FetchEmailBody and the IMAP/JMAP/POP3 providers now return BodyMIMEType.
The Backend interface, daemon RPC protocol, and local cache schema all
carry the MIME type through. view.ProcessBody takes the MIME type and
skips the markdownToHTML pre-pass when it's text/html. The TUI message
fetcher and view call sites are updated for the new field.

## Why?
Right now every email body gets run through md4c before we render it as
HTML. The assumption was that md4c would pass raw HTML through
untouched, but that falls apart on real HTML email — Datadog digests,
marketing stuff, anything with heavy attributes or indentation trips
md4c's html_block rules. When that happens, md4c either escapes the tags
or treats them as code blocks, and the TUI ends up showing literal
`<table>`, `<tr>`, `<td>` instead of the rendered content.
Detecting text/html and skipping the markdown pass fixes that, while
text/plain senders like GitHub notifications and mailing lists keep
their markdown formatting.

### Trade-offs & compatibility
If a text/html sender writes `**bold**` inside their HTML, it won't
render as bold anymore. That's spec-correct behavior, and it's worth
losing to get tables back. On the compat side, MIME type defaults to an
empty string in the wire format and cache, so old cache entries fall
back to the legacy markdown path. No migration needed.

---------

Co-authored-by: Drew Smirnoff <drew@floatpane.com>

Author: YeeP79

backend/backend.go

@@ -27,7 +27,9 @@ type Provider interface {
 // EmailReader fetches emails and their content.
 type EmailReader interface {
 	FetchEmails(ctx context.Context, folder string, limit, offset uint32) ([]Email, error)
-	FetchEmailBody(ctx context.Context, folder string, uid uint32) (string, []Attachment, error)
+	// FetchEmailBody returns the chosen body, its MIME type ("text/html" or
+	// "text/plain"; empty when unknown), parsed attachments, and any error.
+	FetchEmailBody(ctx context.Context, folder string, uid uint32) (string, string, []Attachment, error)
 	FetchAttachment(ctx context.Context, folder string, uid uint32, partID, encoding string) ([]byte, error)
 }
 

backend/imap/imap.go

@@ -36,12 +36,12 @@ func (p *Provider) FetchEmails(_ context.Context, folder string, limit, offset u
 	return toBackendEmails(emails), nil
 }
 
-func (p *Provider) FetchEmailBody(_ context.Context, folder string, uid uint32) (string, []backend.Attachment, error) {
-	body, atts, err := fetcher.FetchEmailBodyFromMailbox(p.account, folder, uid)
+func (p *Provider) FetchEmailBody(_ context.Context, folder string, uid uint32) (string, string, []backend.Attachment, error) {
+	body, mimeType, atts, err := fetcher.FetchEmailBodyFromMailbox(p.account, folder, uid)
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
-	return body, toBackendAttachments(atts), nil
+	return body, mimeType, toBackendAttachments(atts), nil
 }
 
 func (p *Provider) FetchAttachment(_ context.Context, folder string, uid uint32, partID, encoding string) ([]byte, error) {

backend/jmap/jmap.go

@@ -276,10 +276,10 @@ func searchLimit(query backend.SearchQuery) uint32 {
 	return 100
 }
 
-func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (string, []backend.Attachment, error) {
+func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (string, string, []backend.Attachment, error) {
 	jmapID, err := p.lookupJMAPID(uid)
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
 
 	req := &jmapclient.Request{}
@@ -297,25 +297,27 @@ func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (stri
 
 	resp, err := p.client.Do(req)
 	if err != nil {
-		return "", nil, fmt.Errorf("jmap body: %w", err)
+		return "", "", nil, fmt.Errorf("jmap body: %w", err)
 	}
 
 	for _, inv := range resp.Responses {
 		if r, ok := inv.Args.(*email.GetResponse); ok && len(r.List) > 0 {
 			eml := r.List[0]
 
 			// Get body text (prefer HTML)
-			var body string
+			var body, mimeType string
 			for _, part := range eml.HTMLBody {
 				if val, ok := eml.BodyValues[part.PartID]; ok {
 					body = val.Value
+					mimeType = "text/html"
 					break
 				}
 			}
 			if body == "" {
 				for _, part := range eml.TextBody {
 					if val, ok := eml.BodyValues[part.PartID]; ok {
 						body = val.Value
+						mimeType = "text/plain"
 						break
 					}
 				}
@@ -336,11 +338,11 @@ func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (stri
 				atts = append(atts, a)
 			}
 
-			return body, atts, nil
+			return body, mimeType, atts, nil
 		}
 	}
 
-	return "", nil, fmt.Errorf("jmap: email not found")
+	return "", "", nil, fmt.Errorf("jmap: email not found")
 }
 
 func (p *Provider) FetchAttachment(_ context.Context, _ string, _ uint32, partID, _ string) ([]byte, error) {

backend/pop3/pop3.go

@@ -131,21 +131,21 @@ func (p *Provider) FetchEmails(_ context.Context, _ string, limit, offset uint32
 	return emails, nil
 }
 
-func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (string, []backend.Attachment, error) {
+func (p *Provider) FetchEmailBody(_ context.Context, _ string, uid uint32) (string, string, []backend.Attachment, error) {
 	conn, err := p.connect()
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
 	defer conn.Quit()
 
 	msgID, err := p.findMessageByUID(conn, uid)
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
 
 	raw, err := conn.RetrRaw(msgID)
 	if err != nil {
-		return "", nil, fmt.Errorf("pop3 retr: %w", err)
+		return "", "", nil, fmt.Errorf("pop3 retr: %w", err)
 	}
 
 	return parseMessageBody(raw)
@@ -352,15 +352,17 @@ func entityToEmail(header *message.Header, msgInfo pop3client.MessageID, account
 }
 
 // parseMessageBody extracts the body text and attachments from a raw message.
-func parseMessageBody(r io.Reader) (string, []backend.Attachment, error) {
+func parseMessageBody(r io.Reader) (string, string, []backend.Attachment, error) {
 	mr, err := gomail.CreateReader(r)
 	if err != nil {
-		// Not a multipart message — read body directly
+		// Not a multipart message — read body directly. We don't know the
+		// content type at this layer; surface empty so the renderer falls
+		// back to its legacy markdown→HTML path.
 		body, err := io.ReadAll(r)
 		if err != nil {
-			return "", nil, err
+			return "", "", nil, err
 		}
-		return string(body), nil, nil
+		return string(body), "", nil, nil
 	}
 
 	var bodyText string
@@ -411,9 +413,9 @@ func parseMessageBody(r io.Reader) (string, []backend.Attachment, error) {
 	}
 
 	if htmlBody != "" {
-		return htmlBody, attachments, nil
+		return htmlBody, "text/html", attachments, nil
 	}
-	return bodyText, attachments, nil
+	return bodyText, "text/plain", attachments, nil
 }
 
 // findAttachmentData walks a raw message to find attachment data by partID.

config/cache.go

@@ -425,6 +425,7 @@ type CachedEmailBody struct {
 	UID            uint32             `json:"uid"`
 	AccountID      string             `json:"account_id"`
 	Body           string             `json:"body"`
+	BodyMIMEType   string             `json:"body_mime_type,omitempty"` // empty for cache rows written before MIME-type tracking; renderer falls back to legacy markdown→HTML pre-pass
 	Attachments    []CachedAttachment `json:"attachments,omitempty"`
 	CachedAt       time.Time          `json:"cached_at"`
 	LastAccessedAt time.Time          `json:"last_accessed_at"`

daemon/handler.go

@@ -154,7 +154,7 @@ func (d *Daemon) handleFetchEmailBody(conn *daemonrpc.Conn, req *daemonrpc.Reque
 	ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout)
 	defer cancel()
 
-	body, attachments, err := p.FetchEmailBody(ctx, params.Folder, params.UID)
+	body, mimeType, attachments, err := p.FetchEmailBody(ctx, params.Folder, params.UID)
 	if err != nil {
 		conn.SendError(req.ID, daemonrpc.ErrCodeInternal, err.Error())
 		return
@@ -172,8 +172,9 @@ func (d *Daemon) handleFetchEmailBody(conn *daemonrpc.Conn, req *daemonrpc.Reque
 	}
 
 	conn.SendResponse(req.ID, daemonrpc.FetchEmailBodyResult{
-		Body:        body,
-		Attachments: attInfos,
+		Body:         body,
+		BodyMIMEType: mimeType,
+		Attachments:  attInfos,
 	})
 }
 

daemonclient/service.go

@@ -16,7 +16,9 @@ import (
 // TUI and CLI use this interface — they don't care which mode is active.
 type Service interface {
 	FetchEmails(accountID, folder string, limit, offset uint32) ([]backend.Email, error)
-	FetchEmailBody(accountID, folder string, uid uint32) (string, []backend.Attachment, error)
+	// FetchEmailBody returns body, MIME type ("text/html"|"text/plain"|""),
+	// attachments, and any error.
+	FetchEmailBody(accountID, folder string, uid uint32) (string, string, []backend.Attachment, error)
 	DeleteEmails(accountID, folder string, uids []uint32) error
 	ArchiveEmails(accountID, folder string, uids []uint32) error
 	MoveEmails(accountID string, uids []uint32, src, dst string) error
@@ -102,15 +104,15 @@ func (s *daemonService) FetchEmails(accountID, folder string, limit, offset uint
 	return emails, err
 }
 
-func (s *daemonService) FetchEmailBody(accountID, folder string, uid uint32) (string, []backend.Attachment, error) {
+func (s *daemonService) FetchEmailBody(accountID, folder string, uid uint32) (string, string, []backend.Attachment, error) {
 	var result daemonrpc.FetchEmailBodyResult
 	err := s.client.Call(daemonrpc.MethodFetchEmailBody, daemonrpc.FetchEmailBodyParams{
 		AccountID: accountID,
 		Folder:    folder,
 		UID:       uid,
 	}, &result)
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
 
 	var attachments []backend.Attachment
@@ -122,7 +124,7 @@ func (s *daemonService) FetchEmailBody(accountID, folder string, uid uint32) (st
 			MIMEType: a.MIMEType,
 		})
 	}
-	return result.Body, attachments, nil
+	return result.Body, result.BodyMIMEType, attachments, nil
 }
 
 func (s *daemonService) DeleteEmails(accountID, folder string, uids []uint32) error {
@@ -251,10 +253,10 @@ func (s *directService) FetchEmails(accountID, folder string, limit, offset uint
 	return p.FetchEmails(context.Background(), folder, limit, offset)
 }
 
-func (s *directService) FetchEmailBody(accountID, folder string, uid uint32) (string, []backend.Attachment, error) {
+func (s *directService) FetchEmailBody(accountID, folder string, uid uint32) (string, string, []backend.Attachment, error) {
 	p, err := s.getProvider(accountID)
 	if err != nil {
-		return "", nil, err
+		return "", "", nil, err
 	}
 	return p.FetchEmailBody(context.Background(), folder, uid)
 }

daemonrpc/protocol.go

@@ -147,8 +147,9 @@ type FetchEmailBodyParams struct {
 }
 
 type FetchEmailBodyResult struct {
-	Body        string           `json:"body"`
-	Attachments []AttachmentInfo `json:"attachments"`
+	Body         string           `json:"body"`
+	BodyMIMEType string           `json:"body_mime_type,omitempty"`
+	Attachments  []AttachmentInfo `json:"attachments"`
 }
 
 type AttachmentInfo struct {