Hey there! Let's troubleshoot why your emersion/go-imap code isn't marking messages as read properly. I’ve spent plenty of time working with this library, so here are the most common issues and fixes to check:

1. Don’t Mix Up UIDs and Sequence Numbers #

If you’re using UidStore, you must pass message UIDs (not regular sequence numbers) to the function. A super common mistake is fetching messages without requesting their UIDs, then passing sequence IDs to UidStore—which the server won’t recognize.

Make sure when you fetch messages, you request the imap.FetchUid field:

// Example fetch to get UIDs of unread messages
seqSet := new(imap.SeqSet)
seqSet.AddRange(1, mbox.Messages)
messages := make(chan *imap.Message, 10)
go func() {
    if err := client.UidFetch(seqSet, []imap.FetchItem{imap.FetchUid, imap.FetchFlags}, messages); err != nil {
        log.Fatal(err)
    }
}()

// Collect UIDs of unread messages
var uids []uint32
for msg := range messages {
    if !msg.Flags.Has(imap.SeenFlag) {
        uids = append(uids, msg.Uid)
    }
}

2. Use the Correct Flag Operation and Flag #

To mark messages as read, you need to add the imap.SeenFlag to the message’s existing flags—not replace them. Using imap.SetFlags instead of imap.AddFlags will overwrite all flags, which might not be what you want, and could fail silently if you’re missing required flags.

Here’s the correct UidStore call:

flags := []interface{}{imap.SeenFlag}
if err := client.UidStore(uids, imap.AddFlags, flags, nil); err != nil {
    log.Fatalf("Failed to mark messages as read: %v", err)
}

3. Ensure You’ve Selected the Right Mailbox #

You can’t modify messages if you haven’t selected the target mailbox (like "INBOX") in read-write mode. Double-check that you’re using client.Select (not client.Examine, which is read-only):

// Select INBOX in read-write mode (second parameter = false)
mbox, err := client.Select("INBOX", false)
if err != nil {
    log.Fatalf("Failed to select INBOX: %v", err)
}

4. Verify Your Search/Fetch Flow #

A complete, working flow should look like this:

1. Connect and authenticate to your IMAP server
2. Select the target mailbox in read-write mode
3. Search for unread messages (or fetch and filter them)
4. Collect their UIDs
5. Use UidStore to add the SeenFlag

Here’s a full, minimal example:

package main

import (
    "log"
    "github.com/emersion/go-imap"
    "github.com/emersion/go-imap/client"
)

func main() {
    // Connect to server
    c, err := client.DialTLS("imap.example.com:993", nil)
    if err != nil {
        log.Fatal(err)
    }
    defer c.Logout()

    // Login
    if err := c.Login("your-email@example.com", "your-password"); err != nil {
        log.Fatal(err)
    }

    // Select INBOX
    mbox, err := c.Select("INBOX", false)
    if err != nil {
        log.Fatal(err)
    }

    // Search for unread messages
    criteria := imap.NewSearchCriteria()
    criteria.Unseen = true
    uids, err := c.UidSearch(criteria)
    if err != nil {
        log.Fatal(err)
    }

    if len(uids) == 0 {
        log.Println("No unread messages found")
        return
    }

    // Mark as read
    flags := []interface{}{imap.SeenFlag}
    if err := c.UidStore(uids, imap.AddFlags, flags, nil); err != nil {
        log.Fatalf("Failed to mark messages as read: %v", err)
    }

    log.Printf("Successfully marked %d messages as read", len(uids))
}

5. Check for Server-Specific Quirks #

Some IMAP servers require an explicit Expunge call to sync changes, though this is rare with modern servers. If you’re still having issues, try adding:

if err := c.Expunge(nil); err != nil {
    log.Printf("Expunge failed: %v", err)
}

If none of these fixes work, print out the exact error message from UidStore—it often contains clues about what’s wrong (like invalid UIDs or insufficient permissions).

内容的提问来源于stack exchange，提问作者freitas