fix panic on gmail (imap_disabled=true)

Author: sspaeti

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 # 2026-05-04
+- **Fix: send from `imap_disabled = true` account no longer panics** — sending an email from an account configured as send-only (typically Gmail with `imap_disabled = true`) crashed the TUI with `nil pointer dereference` in `tokenSourceFor` because the helper called `.TokenSource()` on the intentionally-nil IMAP client. The same nil-deref existed in `imapCli`, `imapCliForAccount`, and `primaryIMAPClient` — any code path that resolved an IMAP client for a send-only account would crash. All four helpers now skip nil entries (and fall back to the first non-nil client where appropriate); `sendEmailCmd` also guards `cli.SaveSent` and `replyCli.MarkAnswered` so a fully send-only configuration silently skips the Sent-folder copy instead of panicking. Four regression tests added in `internal/ui/imap_client_helpers_test.go`
 - **Fix: notify state key keeps IMAP folder name (preserves baselines across upgrades)** — yesterday's label-normalisation fix accidentally changed the persisted state key from `Personal|INBOX` to `Personal|Inbox`, which would have re-baselined every existing user on upgrade and silently swallowed one round of notifications. `MaybeNotify` now takes both the IMAP name (used for the state key) and the UI label (used only for the allowlist comparison) so existing `notify_state.json` files keep working untouched. Regression test added
 - **Fix: `[notifications].folders` allowlist now matches custom IMAP folder names** — the allowlist compared user-configured labels (e.g. `"PaperTrail"`) against runtime IMAP folder names (e.g. `"HEY/Paper Trail"` or `"[Gmail]/All Mail"`) and silently dropped notifications when the two differed. Folders are now normalised to their UI label via a new `FoldersConfig.LabelFor()` helper before the allowlist check, so users with non-default IMAP folder names get notifications correctly. Regression test added in `internal/config/config_test.go`
 - **Fix: notifier can no longer freeze the TUI** — `Send` now runs `notify-send` (or whatever `[notifications].command` points to) under a 2-second `context.WithTimeout` plus a 500 ms `cmd.WaitDelay`. A hung notification daemon (broken DBus, mako restarting, …) returns a clear `notify-send: timed out after 2s` status instead of blocking the bubbletea Update loop. Test exercises the timeout path with a script that sleeps 60 s

internal/ui/model.go

@@ -682,10 +682,12 @@ func New(cfg *config.Config, clients []*imap.Client, sc *screener.Screener, mail
 }
 
 // tokenSourceFor returns the OAuth2 token source for the account with the
-// given name, or nil if the account uses plain password authentication.
+// given name, or nil if the account uses plain password authentication or
+// is configured as send-only (imap_disabled — its client is nil because
+// neomd never opened an IMAP connection).
 func (m Model) tokenSourceFor(accountName string) func() (string, error) {
 	for i, acc := range m.accounts {
-		if acc.Name == accountName && i < len(m.clients) {
+		if acc.Name == accountName && i < len(m.clients) && m.clients[i] != nil {
 			return m.clients[i].TokenSource()
 		}
 	}
@@ -748,18 +750,24 @@ func (m Model) presendSMTPAccount() config.AccountConfig {
 
 func (m Model) imapCliForAccount(accountName string) *imap.Client {
 	for i, a := range m.accounts {
-		if strings.EqualFold(a.Name, accountName) && i < len(m.clients) {
+		if strings.EqualFold(a.Name, accountName) && i < len(m.clients) && m.clients[i] != nil {
 			return m.clients[i]
 		}
 	}
+	// Account not found, or its client is nil because imap_disabled — fall
+	// back to whatever imapCli / primaryIMAPClient resolves to.
 	return m.imapCli()
 }
 
 func (m Model) primaryIMAPClient() *imap.Client {
-	if len(m.clients) > 0 {
-		return m.clients[0]
+	// Pick the first non-nil client — accounts with imap_disabled = true
+	// have a nil entry by design, so we cannot blindly use index 0.
+	for _, c := range m.clients {
+		if c != nil {
+			return c
+		}
 	}
-	return m.imapCli()
+	return nil
 }
 
 func (m Model) sentDraftsIMAPClient() *imap.Client {
@@ -779,12 +787,13 @@ func (m *Model) applyEditedFrom(from string) {
 	}
 }
 
-// imapCli returns the IMAP client for the active account.
+// imapCli returns the IMAP client for the active account, falling back to
+// the first non-nil client if the active account is imap_disabled.
 func (m Model) imapCli() *imap.Client {
-	if m.accountI < len(m.clients) {
+	if m.accountI < len(m.clients) && m.clients[m.accountI] != nil {
 		return m.clients[m.accountI]
 	}
-	return m.clients[0]
+	return m.primaryIMAPClient()
 }
 
 func (m Model) Init() tea.Cmd {
@@ -890,11 +899,16 @@ func (m Model) sendEmailCmd(smtpAcct config.AccountConfig, from, to, cc, bcc, su
 			return sendDoneMsg{err: err}
 		}
 		// Save copy to Sent; non-fatal if it fails, but warn user.
-		if saveErr := cli.SaveSent(nil, sentFolder, raw); saveErr != nil {
-			return sendDoneMsg{warning: "Sent, but failed to save to Sent folder: " + saveErr.Error(), replyToUID: replyToUID, replyToFolder: replyToFolder}
+		// cli can be nil when every configured account has imap_disabled = true
+		// (send-only setups) — in that case there is no IMAP target for the
+		// Sent copy, so we skip silently.
+		if cli != nil {
+			if saveErr := cli.SaveSent(nil, sentFolder, raw); saveErr != nil {
+				return sendDoneMsg{warning: "Sent, but failed to save to Sent folder: " + saveErr.Error(), replyToUID: replyToUID, replyToFolder: replyToFolder}
+			}
 		}
 		// Mark original email as \Answered (non-fatal).
-		if replyToUID > 0 && replyToFolder != "" {
+		if replyToUID > 0 && replyToFolder != "" && replyCli != nil {
 			_ = replyCli.MarkAnswered(nil, replyToFolder, replyToUID)
 		}
 		return sendDoneMsg{replyToUID: replyToUID, replyToFolder: replyToFolder}

internal/ui/model_test.go

@@ -287,6 +287,76 @@ func TestSentDraftsIMAPClient_FollowsSendingAccountWhenEnabled(t *testing.T) {
 	}
 }
 
+// imap_disabled = true accounts (typically a Gmail set up for SMTP-only)
+// produce a nil entry in m.clients by design (cmd/neomd/main.go appends nil
+// for those accounts).  Every helper that walks m.clients[i] must skip the
+// nil entries — historically several didn't, and a perfectly normal "send
+// from Gmail" flow crashed the TUI with `nil pointer dereference` in
+// tokenSourceFor.  These tests pin all four resolver helpers so that
+// regression cannot recur silently.
+
+func TestTokenSourceFor_NilClientReturnsNil(t *testing.T) {
+	cfg := &config.Config{
+		Accounts: []config.AccountConfig{
+			{Name: "Personal"},
+			{Name: "Gmail", IMAPDisabled: true},
+		},
+	}
+	m := Model{
+		cfg:      cfg,
+		accounts: cfg.ActiveAccounts(),
+		clients:  []*imap.Client{imap.New(imap.Config{Host: "personal"}), nil},
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("tokenSourceFor panicked on nil client: %v", r)
+		}
+	}()
+	if m.tokenSourceFor("Gmail") != nil {
+		t.Error("tokenSourceFor(send-only Gmail) should return nil, not a token source from nil client")
+	}
+}
+
+func TestImapCliForAccount_FallsBackWhenClientNil(t *testing.T) {
+	cfg := &config.Config{
+		Accounts: []config.AccountConfig{
+			{Name: "Personal"},
+			{Name: "Gmail", IMAPDisabled: true},
+		},
+	}
+	personal := imap.New(imap.Config{Host: "personal"})
+	m := Model{cfg: cfg, accounts: cfg.ActiveAccounts(), clients: []*imap.Client{personal, nil}}
+	if got := m.imapCliForAccount("Gmail"); got != personal {
+		t.Error("imapCliForAccount(Gmail) should fall back to the first non-nil client")
+	}
+}
+
+func TestPrimaryIMAPClient_SkipsNilEntries(t *testing.T) {
+	// Reverse the layout — nil at index 0, real client at index 1.
+	personal := imap.New(imap.Config{Host: "personal"})
+	m := Model{
+		cfg:      &config.Config{Accounts: []config.AccountConfig{{Name: "Gmail", IMAPDisabled: true}, {Name: "Personal"}}},
+		accounts: []config.AccountConfig{{Name: "Gmail", IMAPDisabled: true}, {Name: "Personal"}},
+		clients:  []*imap.Client{nil, personal},
+	}
+	if got := m.primaryIMAPClient(); got != personal {
+		t.Error("primaryIMAPClient should walk past nil entries to the first real client")
+	}
+}
+
+func TestImapCli_FallsBackWhenActiveAccountIMAPDisabled(t *testing.T) {
+	personal := imap.New(imap.Config{Host: "personal"})
+	m := Model{
+		cfg:      &config.Config{Accounts: []config.AccountConfig{{Name: "Personal"}, {Name: "Gmail", IMAPDisabled: true}}},
+		accounts: []config.AccountConfig{{Name: "Personal"}, {Name: "Gmail", IMAPDisabled: true}},
+		clients:  []*imap.Client{personal, nil},
+		accountI: 1, // active = Gmail (nil client)
+	}
+	if got := m.imapCli(); got != personal {
+		t.Error("imapCli should fall back to a non-nil client when the active account is imap_disabled")
+	}
+}
+
 func TestMatchFromAddress(t *testing.T) {
 	cfg := &config.Config{
 		Accounts: []config.AccountConfig{