fix(gmail): handle reply-all to own message correctly

When replying-all to a message you sent, the original sender (you) was
excluded from To, leaving it empty and producing an error. Gmail web
handles this by using the original To recipients as reply targets.

Detect self-reply by checking if the original From matches the user's
primary email or send-as alias, then swap the candidate logic:
- Self-reply: To = original To, CC = original CC
- Normal reply: To = Reply-To or From, CC = original To + CC

Author: malob

.changeset/gmail-default-sender.md

@@ -4,4 +4,4 @@
 
 feat(gmail): auto-populate From header with display name from send-as settings
 
-Fetch the user's send-as identities to set the From header with a display name in all mail helpers (+send, +reply, +reply-all, +forward), matching Gmail web client behavior. Also enriches bare `--from` emails with their configured display name. In reply-all, uses the send-as endpoint instead of `/users/me/profile` for self-email dedup (with profile as fallback).
+Fetch the user's send-as identities to set the From header with a display name in all mail helpers (+send, +reply, +reply-all, +forward), matching Gmail web client behavior. Also enriches bare `--from` emails with their configured display name.

.changeset/gmail-self-reply-fix.md

@@ -0,0 +1,7 @@
+---
+"@googleworkspace/cli": patch
+---
+
+fix(gmail): handle reply-all to own message correctly
+
+Reply-all to a message you sent no longer errors with "No To recipient remains." The original To recipients are now used as reply targets, matching Gmail web client behavior.

src/helpers/gmail/mod.rs

@@ -440,28 +440,20 @@ fn parse_send_as_response(body: &Value) -> Vec<SendAsIdentity> {
 /// Given pre-fetched send-as identities, resolve the `From` address.
 ///
 /// - `from` is `None` → returns the default send-as identity
-/// - `from` has bare emails (no display name) → enriches with send-as display names
-/// - `from` already has display names → returns as-is
+/// - `from` has bare emails → enriches with send-as display names (mailboxes
+///   that already have a display name pass through unchanged)
 fn resolve_sender_from_identities(
     from: Option<&[Mailbox]>,
     identities: &[SendAsIdentity],
 ) -> Option<Vec<Mailbox>> {
-    // All provided mailboxes already have display names — nothing to resolve.
-    // (Also checked in resolve_sender to skip the API call; duplicated here
-    // so this pure function is independently correct for testing.)
-    if let Some(addrs) = from {
-        if addrs.iter().all(|m| m.name.is_some()) {
-            return Some(addrs.to_vec());
-        }
-    }
-
     match from {
         // No from provided → use default identity.
         None => identities
             .iter()
             .find(|id| id.is_default)
             .map(|id| vec![id.mailbox.clone()]),
-        // Bare emails without display names → enrich from send-as list.
+        // Enrich bare emails (no display name) from the send-as list.
+        // Mailboxes that already have a display name pass through unchanged.
         Some(addrs) => {
             let enriched: Vec<Mailbox> = addrs
                 .iter()
@@ -484,9 +476,9 @@ fn resolve_sender_from_identities(
 /// Resolve the `From` address using Gmail send-as identities.
 ///
 /// Fetches send-as settings and enriches the From address with the display name.
-/// Degrades gracefully if the API call fails — returns `Ok(None)` when `from` is
-/// `None` and no default identity exists, or when the API call fails and `from`
-/// was not provided.
+/// Degrades gracefully if the API call fails — returns the original `from`
+/// addresses unchanged (without display name enrichment), or `Ok(None)` if
+/// `from` was not provided.
 ///
 /// Note: this resolves the *sender identity* for the From header only. Callers
 /// that need the authenticated user's *primary* email (e.g. reply-all self-dedup)

src/helpers/gmail/reply.rs

@@ -148,8 +148,9 @@ pub(super) struct ReplyConfig {
     pub attachments: Vec<Attachment>,
 }
 
-/// Fetch the authenticated user's email from the Gmail profile API.
-/// Used as a fallback for reply-all self-dedup when the sendAs endpoint fails.
+/// Fetch the authenticated user's primary email from the Gmail profile API.
+/// Used in reply-all for self-dedup (excluding the user from recipients) and
+/// self-reply detection (switching to original-To-based addressing).
 async fn fetch_user_email(client: &reqwest::Client, token: &str) -> Result<String, GwsError> {
     let resp = crate::client::send_with_retry(|| {
         client
@@ -201,8 +202,33 @@ fn build_reply_all_recipients(
     self_email: Option<&str>,
     from_alias: Option<&str>,
 ) -> Result<ReplyRecipients, GwsError> {
-    let to_candidates = extract_reply_to_address(original);
     let excluded = collect_excluded_emails(remove, self_email, from_alias);
+
+    // When replying to your own message, the original sender (you) would be
+    // excluded from To, leaving it empty. Gmail web handles this by using the
+    // original To recipients as the reply targets instead, ignoring Reply-To.
+    // (Gmail ignores Reply-To on self-sent messages — we approximate this by
+    // checking the primary address and the current From alias.)
+    // Detect self-reply by checking if the original sender matches the user's
+    // primary or alias.
+    let is_self_reply = [self_email, from_alias]
+        .into_iter()
+        .flatten()
+        .any(|e| original.from.email.eq_ignore_ascii_case(e));
+
+    let (to_candidates, mut cc_candidates) = if is_self_reply {
+        // Self-reply: To = original To, CC = original CC
+        let cc = original.cc.clone().unwrap_or_default();
+        (original.to.clone(), cc)
+    } else {
+        // Normal reply: To = Reply-To or From, CC = original To + CC
+        let mut cc = original.to.clone();
+        if let Some(orig_cc) = &original.cc {
+            cc.extend(orig_cc.iter().cloned());
+        }
+        (extract_reply_to_address(original), cc)
+    };
+
     let mut to_emails = std::collections::HashSet::new();
     let to: Vec<Mailbox> = to_candidates
         .into_iter()
@@ -215,18 +241,12 @@ fn build_reply_all_recipients(
         })
         .collect();
 
-    // Combine original To and Cc as CC candidates
-    let mut cc_candidates: Vec<Mailbox> = original.to.clone();
-    if let Some(orig_cc) = &original.cc {
-        cc_candidates.extend(orig_cc.iter().cloned());
-    }
-
     // Add extra CC if provided
     if let Some(extra) = extra_cc {
         cc_candidates.extend(extra.iter().cloned());
     }
 
-    // Filter CC: remove reply-to recipients, excluded addresses, and duplicates
+    // Filter CC: remove To recipients, excluded addresses, and duplicates
     let mut seen = std::collections::HashSet::new();
     let cc: Vec<Mailbox> = cc_candidates
         .into_iter()
@@ -601,7 +621,9 @@ mod tests {
     }
 
     #[test]
-    fn test_build_reply_all_from_alias_removes_primary_returns_empty_to() {
+    fn test_build_reply_all_from_alias_is_self_reply() {
+        // When from_alias matches original.from, this is a self-reply.
+        // To should be the original To recipients, not empty.
         let original = OriginalMessage {
             from: Mailbox::parse("sales@example.com"),
             to: vec![Mailbox::parse("bob@example.com")],
@@ -617,7 +639,8 @@ mod tests {
             Some("sales@example.com"),
         )
         .unwrap();
-        assert!(recipients.to.is_empty());
+        assert_eq!(recipients.to.len(), 1);
+        assert_eq!(recipients.to[0].email, "bob@example.com");
     }
 
     fn make_reply_matches(args: &[&str]) -> ArgMatches {
@@ -997,6 +1020,71 @@ mod tests {
         assert!(cc.iter().any(|m| m.email == "carol@example.com"));
     }
 
+    // --- self-reply tests ---
+
+    #[test]
+    fn test_reply_all_to_own_message_puts_original_to_in_to() {
+        let original = OriginalMessage {
+            from: Mailbox::parse("me@example.com"),
+            to: vec![
+                Mailbox::parse("alice@example.com"),
+                Mailbox::parse("bob@example.com"),
+            ],
+            cc: Some(vec![Mailbox::parse("carol@example.com")]),
+            ..Default::default()
+        };
+        let recipients =
+            build_reply_all_recipients(&original, None, None, Some("me@example.com"), None)
+                .unwrap();
+        // To should be the original To recipients, not the original sender
+        assert_eq!(recipients.to.len(), 2);
+        assert!(recipients.to.iter().any(|m| m.email == "alice@example.com"));
+        assert!(recipients.to.iter().any(|m| m.email == "bob@example.com"));
+        // CC should be the original CC
+        let cc = recipients.cc.unwrap();
+        assert_eq!(cc.len(), 1);
+        assert!(cc.iter().any(|m| m.email == "carol@example.com"));
+    }
+
+    #[test]
+    fn test_reply_all_to_own_message_detected_via_alias() {
+        let original = OriginalMessage {
+            from: Mailbox::parse("alias@work.com"),
+            to: vec![Mailbox::parse("alice@example.com")],
+            ..Default::default()
+        };
+        // self_email is primary, from_alias matches the original sender
+        let recipients = build_reply_all_recipients(
+            &original,
+            None,
+            None,
+            Some("me@gmail.com"),
+            Some("alias@work.com"),
+        )
+        .unwrap();
+        assert_eq!(recipients.to.len(), 1);
+        assert_eq!(recipients.to[0].email, "alice@example.com");
+    }
+
+    #[test]
+    fn test_reply_all_to_own_message_excludes_self_from_original_to() {
+        // You sent to yourself + Alice (e.g. a note-to-self CC'd to someone)
+        let original = OriginalMessage {
+            from: Mailbox::parse("me@example.com"),
+            to: vec![
+                Mailbox::parse("me@example.com"),
+                Mailbox::parse("alice@example.com"),
+            ],
+            ..Default::default()
+        };
+        let recipients =
+            build_reply_all_recipients(&original, None, None, Some("me@example.com"), None)
+                .unwrap();
+        // Self should still be excluded from To
+        assert_eq!(recipients.to.len(), 1);
+        assert_eq!(recipients.to[0].email, "alice@example.com");
+    }
+
     // --- dedup_recipients tests ---
 
     #[test]