feat(notify): branded Slack Block Kit alerts with CloudDrove footer (#31)

* feat(notify): branded Slack Block Kit alerts with CloudDrove footer

Slack notifications were plain text and looked unpolished. Render them as
Block Kit attachments instead: a colored bar (green for new syncs, red for
failures), an emoji header with the count, code-formatted image refs grouped
per destination in detailed mode, and a constant CloudDrove-branded context
footer (logo + clouddrove.com link).

- internal/notify/slack.go: add Message/Section types and a Block Kit
  renderer (header, auto-split section blocks under Slack's char limit,
  divider, branded footer). Keep SendText for plain callers.
- internal/sync/sync.go: build notify.Message values instead of plain
  strings; preserve compact/detailed formats and truncation caps.
- tests: rewrite the sync formatter tests for the new builders and add
  notify tests for block structure, footer branding, payload POST, and
  long-content section splitting.

* feat(notify): use official CloudDrove favicon for Slack footer logo

Switch the footer logo from the GitHub org avatar to the official
clouddrove.com favicon (apple-touch-icon.png — PNG, since Slack image
blocks do not render .ico).

* feat(notify): add SyncerD logo thumbnail to Slack alerts

Show the SyncerD product logo (assets/syncerd-logo.png via raw GitHub URL)
as an image accessory on the first section block, alongside the CloudDrove
favicon in the footer.

* feat(notify): use SyncerD logo in footer; drop CloudDrove favicon

Footer now reads [SyncerD logo] SyncerD — powered by CloudDrove. Removes
the CloudDrove favicon image (text link to clouddrove.com kept) and the
trailing emoji.

* feat(notify): drop large section thumbnail; keep small footer logo only

The section accessory rendered the SyncerD logo as a large thumbnail. Remove
it so the only image is the small (~16px) footer context icon.

---------

Co-authored-by: Anmol Nagpal <ianmolnagpal@gmail.com>

Author: clouddrove-ci

internal/notify/slack.go

@@ -9,6 +9,22 @@ import (
 	"time"
 )
 
+// CloudDrove branding used in every notification footer.
+const (
+	brandName = "CloudDrove"
+	brandURL  = "https://clouddrove.com"
+	// SyncerD product logo, used as the alert thumbnail and footer icon.
+	syncerdLogoURL = "https://raw.githubusercontent.com/clouddrove/SyncerD/master/assets/syncerd-logo.png"
+
+	// Attachment color bars.
+	ColorSuccess = "#2EB67D" // green
+	ColorFailure = "#E01E5A" // red
+
+	// Slack limits we stay under.
+	maxHeaderChars  = 150
+	maxSectionChars = 2900
+)
+
 type SlackClient struct {
 	WebhookURL string
 	Channel    string
@@ -17,14 +33,145 @@ type SlackClient struct {
 	HTTP       *http.Client
 }
 
+// Section is one logical group in a notification (e.g. a destination and its
+// affected image refs). Heading is optional.
+type Section struct {
+	Heading string
+	Lines   []string
+}
+
+// Message is a provider-agnostic notification that Send renders into Slack
+// Block Kit with consistent CloudDrove branding.
+type Message struct {
+	Emoji    string // e.g. ":white_check_mark:"
+	Title    string // e.g. "3 image(s)/tag(s) synced"
+	Color    string // ColorSuccess / ColorFailure
+	Fallback string // plain-text summary for notifications/screen readers
+	Sections []Section
+}
+
+// --- Block Kit payload types ---
+
 type slackPayload struct {
-	Text      string `json:"text"`
-	Channel   string `json:"channel,omitempty"`
-	Username  string `json:"username,omitempty"`
-	IconEmoji string `json:"icon_emoji,omitempty"`
+	Channel     string       `json:"channel,omitempty"`
+	Username    string       `json:"username,omitempty"`
+	IconEmoji   string       `json:"icon_emoji,omitempty"`
+	Text        string       `json:"text,omitempty"` // fallback
+	Attachments []attachment `json:"attachments,omitempty"`
+}
+
+type attachment struct {
+	Color  string  `json:"color,omitempty"`
+	Blocks []block `json:"blocks,omitempty"`
+}
+
+// block is a generic Block Kit block. Fields are pointers/omitempty so a single
+// type can represent header, section, divider, and context blocks.
+type block struct {
+	Type     string      `json:"type"`
+	Text     *textObject `json:"text,omitempty"`
+	Elements []any       `json:"elements,omitempty"`
 }
 
+type textObject struct {
+	Type  string `json:"type"` // "plain_text" | "mrkdwn"
+	Text  string `json:"text"`
+	Emoji bool   `json:"emoji,omitempty"`
+}
+
+type imageElement struct {
+	Type     string `json:"type"` // "image"
+	ImageURL string `json:"image_url"`
+	AltText  string `json:"alt_text"`
+}
+
+// SendText sends a plain-text message (kept for simple callers/tests).
 func (c *SlackClient) SendText(ctx context.Context, text string) error {
+	return c.send(ctx, slackPayload{
+		Channel:   c.Channel,
+		Username:  c.Username,
+		IconEmoji: c.IconEmoji,
+		Text:      text,
+	})
+}
+
+// Send renders a Message as a branded Block Kit notification.
+func (c *SlackClient) Send(ctx context.Context, m Message) error {
+	if c == nil || c.WebhookURL == "" {
+		return nil
+	}
+	return c.send(ctx, slackPayload{
+		Channel:     c.Channel,
+		Username:    c.Username,
+		IconEmoji:   c.IconEmoji,
+		Text:        m.Fallback,
+		Attachments: []attachment{{Color: m.Color, Blocks: c.renderBlocks(m)}},
+	})
+}
+
+func (c *SlackClient) renderBlocks(m Message) []block {
+	blocks := make([]block, 0, len(m.Sections)+3)
+
+	header := m.Title
+	if m.Emoji != "" {
+		header = m.Emoji + " " + m.Title
+	}
+	blocks = append(blocks, block{
+		Type: "header",
+		Text: &textObject{Type: "plain_text", Text: truncate(header, maxHeaderChars), Emoji: true},
+	})
+
+	for _, sec := range m.Sections {
+		var buf bytes.Buffer
+		if sec.Heading != "" {
+			buf.WriteString("*" + sec.Heading + "*\n")
+		}
+		for _, line := range sec.Lines {
+			// Flush into a new section block before exceeding Slack's limit.
+			if buf.Len()+len(line)+1 > maxSectionChars {
+				blocks = append(blocks, sectionBlock(buf.String()))
+				buf.Reset()
+			}
+			buf.WriteString(line)
+			buf.WriteByte('\n')
+		}
+		if buf.Len() > 0 {
+			blocks = append(blocks, sectionBlock(buf.String()))
+		}
+	}
+
+	blocks = append(blocks, block{Type: "divider"})
+	blocks = append(blocks, footerBlock())
+	return blocks
+}
+
+func sectionBlock(text string) block {
+	return block{Type: "section", Text: &textObject{Type: "mrkdwn", Text: text}}
+}
+
+// footerBlock is the constant CloudDrove-branded context footer.
+func footerBlock() block {
+	return block{
+		Type: "context",
+		Elements: []any{
+			imageElement{Type: "image", ImageURL: syncerdLogoURL, AltText: "SyncerD"},
+			&textObject{Type: "mrkdwn", Text: fmt.Sprintf(
+				"*SyncerD* — powered by <%s|%s>", brandURL, brandName)},
+		},
+	}
+}
+
+func truncate(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	if max <= 1 {
+		return s[:max]
+	}
+	return s[:max-1] + "…"
+}
+
+func (c *SlackClient) send(ctx context.Context, payload slackPayload) error {
 	if c == nil || c.WebhookURL == "" {
 		return nil
 	}
@@ -33,12 +180,6 @@ func (c *SlackClient) SendText(ctx context.Context, text string) error {
 		httpClient = &http.Client{Timeout: 10 * time.Second}
 	}
 
-	payload := slackPayload{
-		Text:      text,
-		Channel:   c.Channel,
-		Username:  c.Username,
-		IconEmoji: c.IconEmoji,
-	}
 	b, err := json.Marshal(payload)
 	if err != nil {
 		return fmt.Errorf("marshal slack payload: %w", err)

internal/notify/slack_test.go

@@ -0,0 +1,114 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func sampleMessage() Message {
+	return Message{
+		Emoji:    ":white_check_mark:",
+		Title:    "2 image(s)/tag(s) synced",
+		Color:    ColorSuccess,
+		Fallback: "SyncerD: 2 synced",
+		Sections: []Section{{Lines: []string{"• `a`", "• `b`"}}},
+	}
+}
+
+func TestRenderBlocksStructure(t *testing.T) {
+	c := &SlackClient{}
+	blocks := c.renderBlocks(sampleMessage())
+
+	if len(blocks) < 3 {
+		t.Fatalf("expected header + section + footer, got %d blocks", len(blocks))
+	}
+	if blocks[0].Type != "header" {
+		t.Errorf("first block should be header, got %q", blocks[0].Type)
+	}
+	if blocks[0].Text == nil || !strings.Contains(blocks[0].Text.Text, "synced") {
+		t.Errorf("header text missing title: %+v", blocks[0].Text)
+	}
+
+	footer := blocks[len(blocks)-1]
+	if footer.Type != "context" {
+		t.Fatalf("last block should be context footer, got %q", footer.Type)
+	}
+	var hasBrand, hasLogo bool
+	for _, el := range footer.Elements {
+		switch v := el.(type) {
+		case *textObject:
+			if strings.Contains(v.Text, brandName) && strings.Contains(v.Text, brandURL) {
+				hasBrand = true
+			}
+		case imageElement:
+			if v.ImageURL == syncerdLogoURL {
+				hasLogo = true
+			}
+		}
+	}
+	if !hasBrand {
+		t.Errorf("footer missing CloudDrove branding text")
+	}
+	if !hasLogo {
+		t.Errorf("footer missing CloudDrove logo image")
+	}
+}
+
+func TestSendPostsBlockKitPayload(t *testing.T) {
+	var got map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewDecoder(r.Body).Decode(&got)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	c := &SlackClient{WebhookURL: srv.URL}
+	if err := c.Send(context.Background(), sampleMessage()); err != nil {
+		t.Fatalf("Send returned error: %v", err)
+	}
+
+	atts, ok := got["attachments"].([]any)
+	if !ok || len(atts) != 1 {
+		t.Fatalf("expected one attachment, got %v", got["attachments"])
+	}
+	att := atts[0].(map[string]any)
+	if att["color"] != ColorSuccess {
+		t.Errorf("expected success color, got %v", att["color"])
+	}
+	if got["text"] != "SyncerD: 2 synced" {
+		t.Errorf("expected fallback text, got %v", got["text"])
+	}
+}
+
+func TestSendNoopWithoutWebhook(t *testing.T) {
+	c := &SlackClient{}
+	if err := c.Send(context.Background(), sampleMessage()); err != nil {
+		t.Errorf("expected nil error with empty webhook, got %v", err)
+	}
+}
+
+func TestLongSectionSplitsIntoMultipleBlocks(t *testing.T) {
+	var lines []string
+	for i := 0; i < 400; i++ {
+		lines = append(lines, "• `registry.example.com/library/some-image:tag-1234567890`")
+	}
+	c := &SlackClient{}
+	blocks := c.renderBlocks(Message{Title: "t", Sections: []Section{{Lines: lines}}})
+
+	sectionCount := 0
+	for _, b := range blocks {
+		if b.Type == "section" {
+			sectionCount++
+			if b.Text != nil && len(b.Text.Text) > maxSectionChars {
+				t.Errorf("section exceeds Slack limit: %d chars", len(b.Text.Text))
+			}
+		}
+	}
+	if sectionCount < 2 {
+		t.Errorf("expected long content to split into multiple section blocks, got %d", sectionCount)
+	}
+}