gogcli/internal/cmd/gmail_thread.go

package cmd

import (
	"context"
	"encoding/base64"
	"errors"
	"fmt"
	"net/url"
	"os"
	"path/filepath"
	"strings"

	"google.golang.org/api/gmail/v1"

	"github.com/steipete/gogcli/internal/outfmt"
	"github.com/steipete/gogcli/internal/ui"
)

type GmailThreadCmd struct {
	Get    GmailThreadGetCmd    `cmd:"" name:"get" help:"Get a thread with all messages (optionally download attachments)"`
	Modify GmailThreadModifyCmd `cmd:"" name:"modify" help:"Modify labels on all messages in a thread"`
}

type GmailThreadGetCmd struct {
	ThreadID string `arg:"" name:"threadId" help:"Thread ID"`
	Download bool   `name:"download" help:"Download attachments"`
	OutDir   string `name:"out-dir" help:"Directory to write attachments to (default: current directory)"`
}

func (c *GmailThreadGetCmd) Run(ctx context.Context, flags *RootFlags) error {
	u := ui.FromContext(ctx)
	account, err := requireAccount(flags)
	if err != nil {
		return err
	}
	threadID := strings.TrimSpace(c.ThreadID)
	if threadID == "" {
		return usage("empty threadId")
	}

	svc, err := newGmailService(ctx, account)
	if err != nil {
		return err
	}

	thread, err := svc.Users.Threads.Get("me", threadID).Format("full").Context(ctx).Do()
	if err != nil {
		return err
	}

	var attachDir string
	if c.Download {
		if strings.TrimSpace(c.OutDir) == "" {
			// Default: current directory, not gogcli config dir.
			attachDir = "."
		} else {
			attachDir = filepath.Clean(c.OutDir)
		}
	}

	if outfmt.IsJSON(ctx) {
		type downloaded struct {
			MessageID     string `json:"messageId"`
			AttachmentID  string `json:"attachmentId"`
			Filename      string `json:"filename"`
			MimeType      string `json:"mimeType,omitempty"`
			Size          int64  `json:"size,omitempty"`
			Path          string `json:"path"`
			Cached        bool   `json:"cached"`
			DownloadError string `json:"error,omitempty"`
		}
		downloadedFiles := make([]downloaded, 0)
		if c.Download && thread != nil {
			for _, msg := range thread.Messages {
				if msg == nil || msg.Id == "" {
					continue
				}
				for _, a := range collectAttachments(msg.Payload) {
					outPath, cached, err := downloadAttachment(ctx, svc, msg.Id, a, attachDir)
					if err != nil {
						return err
					}
					df := downloaded{
						MessageID:    msg.Id,
						AttachmentID: a.AttachmentID,
						Filename:     a.Filename,
						MimeType:     a.MimeType,
						Size:         a.Size,
						Path:         outPath,
						Cached:       cached,
					}
					downloadedFiles = append(downloadedFiles, df)
				}
			}
		}
		return outfmt.WriteJSON(os.Stdout, map[string]any{
			"thread":     thread,
			"downloaded": downloadedFiles,
		})
	}
	if thread == nil || len(thread.Messages) == 0 {
		u.Err().Println("Empty thread")
		return nil
	}

	for _, msg := range thread.Messages {
		if msg == nil {
			continue
		}
		u.Out().Printf("Message: %s", msg.Id)
		u.Out().Printf("From: %s", headerValue(msg.Payload, "From"))
		u.Out().Printf("To: %s", headerValue(msg.Payload, "To"))
		u.Out().Printf("Subject: %s", headerValue(msg.Payload, "Subject"))
		u.Out().Printf("Date: %s", headerValue(msg.Payload, "Date"))
		u.Out().Println("")

		body := bestBodyText(msg.Payload)
		if body != "" {
			u.Out().Println(body)
			u.Out().Println("")
		}

		attachments := collectAttachments(msg.Payload)
		if len(attachments) > 0 {
			u.Out().Println("Attachments:")
			for _, a := range attachments {
				u.Out().Printf("  - %s (%d bytes)", a.Filename, a.Size)
			}
			u.Out().Println("")
		}

		if c.Download && len(attachments) > 0 {
			for _, a := range attachments {
				outPath, cached, err := downloadAttachment(ctx, svc, msg.Id, a, attachDir)
				if err != nil {
					return err
				}
				if cached {
					u.Out().Printf("Cached: %s", outPath)
				} else {
					u.Out().Successf("Saved: %s", outPath)
				}
			}
			u.Out().Println("")
		}
	}

	return nil
}

type GmailThreadModifyCmd struct {
	ThreadID string `arg:"" name:"threadId" help:"Thread ID"`
	Add      string `name:"add" help:"Labels to add (comma-separated, name or ID)"`
	Remove   string `name:"remove" help:"Labels to remove (comma-separated, name or ID)"`
}

func (c *GmailThreadModifyCmd) Run(ctx context.Context, flags *RootFlags) error {
	u := ui.FromContext(ctx)
	account, err := requireAccount(flags)
	if err != nil {
		return err
	}
	threadID := strings.TrimSpace(c.ThreadID)
	if threadID == "" {
		return usage("empty threadId")
	}

	addLabels := splitCSV(c.Add)
	removeLabels := splitCSV(c.Remove)
	if len(addLabels) == 0 && len(removeLabels) == 0 {
		return usage("must specify --add and/or --remove")
	}

	svc, err := newGmailService(ctx, account)
	if err != nil {
		return err
	}

	// Resolve label names to IDs
	idMap, err := fetchLabelNameToID(svc)
	if err != nil {
		return err
	}

	addIDs := resolveLabelIDs(addLabels, idMap)
	removeIDs := resolveLabelIDs(removeLabels, idMap)

	// Use Gmail's Threads.Modify API
	_, err = svc.Users.Threads.Modify("me", threadID, &gmail.ModifyThreadRequest{
		AddLabelIds:    addIDs,
		RemoveLabelIds: removeIDs,
	}).Context(ctx).Do()
	if err != nil {
		return err
	}

	if outfmt.IsJSON(ctx) {
		return outfmt.WriteJSON(os.Stdout, map[string]any{
			"modified":      threadID,
			"addedLabels":   addIDs,
			"removedLabels": removeIDs,
		})
	}

	u.Out().Printf("Modified thread %s", threadID)
	return nil
}

type GmailURLCmd struct {
	ThreadIDs []string `arg:"" name:"threadId" help:"Thread IDs"`
}

func (c *GmailURLCmd) Run(ctx context.Context, flags *RootFlags) error {
	u := ui.FromContext(ctx)
	account, err := requireAccount(flags)
	if err != nil {
		return err
	}
	if outfmt.IsJSON(ctx) {
		urls := make([]map[string]string, 0, len(c.ThreadIDs))
		for _, id := range c.ThreadIDs {
			urls = append(urls, map[string]string{
				"id":  id,
				"url": fmt.Sprintf("https://mail.google.com/mail/?authuser=%s#all/%s", url.QueryEscape(account), id),
			})
		}
		return outfmt.WriteJSON(os.Stdout, map[string]any{"urls": urls})
	}
	for _, id := range c.ThreadIDs {
		threadURL := fmt.Sprintf("https://mail.google.com/mail/?authuser=%s#all/%s", url.QueryEscape(account), id)
		u.Out().Printf("%s\t%s", id, threadURL)
	}
	return nil
}

type attachmentInfo struct {
	Filename     string
	Size         int64
	MimeType     string
	AttachmentID string
}

func collectAttachments(p *gmail.MessagePart) []attachmentInfo {
	if p == nil {
		return nil
	}
	var out []attachmentInfo
	if p.Filename != "" && p.Body != nil && p.Body.AttachmentId != "" {
		out = append(out, attachmentInfo{
			Filename:     p.Filename,
			Size:         p.Body.Size,
			MimeType:     p.MimeType,
			AttachmentID: p.Body.AttachmentId,
		})
	}
	for _, part := range p.Parts {
		out = append(out, collectAttachments(part)...)
	}
	return out
}

func bestBodyText(p *gmail.MessagePart) string {
	if p == nil {
		return ""
	}
	plain := findPartBody(p, "text/plain")
	if plain != "" {
		return plain
	}
	html := findPartBody(p, "text/html")
	return html
}

func findPartBody(p *gmail.MessagePart, mimeType string) string {
	if p == nil {
		return ""
	}
	if p.MimeType == mimeType && p.Body != nil && p.Body.Data != "" {
		s, err := decodeBase64URL(p.Body.Data)
		if err == nil {
			return s
		}
	}
	for _, part := range p.Parts {
		if s := findPartBody(part, mimeType); s != "" {
			return s
		}
	}
	return ""
}

func decodeBase64URL(s string) (string, error) {
	b, err := base64.RawURLEncoding.DecodeString(s)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

func downloadAttachment(ctx context.Context, svc *gmail.Service, messageID string, a attachmentInfo, dir string) (string, bool, error) {
	if strings.TrimSpace(messageID) == "" || strings.TrimSpace(a.AttachmentID) == "" {
		return "", false, errors.New("missing messageID/attachmentID")
	}
	if strings.TrimSpace(dir) == "" {
		dir = "."
	}
	shortID := a.AttachmentID
	if len(shortID) > 8 {
		shortID = shortID[:8]
	}
	// Sanitize filename to prevent path traversal attacks
	safeFilename := filepath.Base(a.Filename)
	if safeFilename == "" || safeFilename == "." || safeFilename == ".." {
		safeFilename = "attachment"
	}
	filename := fmt.Sprintf("%s_%s_%s", messageID, shortID, safeFilename)
	outPath := filepath.Join(dir, filename)
	path, cached, _, err := downloadAttachmentToPath(ctx, svc, messageID, a.AttachmentID, outPath, a.Size)
	if err != nil {
		return "", false, err
	}
	return path, cached, nil
}