feat: clicky for notifications

.golangci.yml

@@ -19,6 +19,9 @@ linters:
       - linters:
           - staticcheck
         text: 'QF1008:'
+      - linters:
+          - staticcheck
+        text: 'SA1019:.*WithCredentialsJSON'
 formatters:
   exclusions:
     generated: lax

db/notifications.go

@@ -314,7 +314,7 @@ func GetMatchingNotificationSilences(ctx context.Context, resources models.Notif
 func SaveUnsentNotificationToHistory(ctx context.Context, sendHistory models.NotificationSendHistory) error {
 	window := ctx.Properties().Duration("notifications.dedup.window", time.Hour*24)
 
-	return ctx.DB().Exec("SELECT * FROM insert_unsent_notification_to_history(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+	return ctx.DB().Exec("SELECT * FROM insert_unsent_notification_to_history(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
 		sendHistory.NotificationID,
 		sendHistory.SourceEvent,
 		sendHistory.ResourceID,
@@ -327,6 +327,7 @@ func SaveUnsentNotificationToHistory(ctx context.Context, sendHistory models.Not
 		sendHistory.ConnectionID,
 		sendHistory.PlaybookRunID,
 		sendHistory.Body,
+		sendHistory.BodyPayload,
 	).Error
 }
 

go.mod

@@ -438,6 +438,8 @@ require (
 
 // replace github.com/flanksource/duty => ../duty
 
+// replace github.com/flanksource/clicky => ../clicky
+
 // replace github.com/flanksource/gomplate/v3 => ../gomplate
 
 // replace github.com/flanksource/commons => ../commons

mcp/notifications.go

@@ -6,11 +6,17 @@ import (
 	"time"
 
 	"github.com/flanksource/duty/models"
+	"github.com/flanksource/incident-commander/notification"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
 	"github.com/timberio/go-datemath"
 )
 
+type notificationDetailResponse struct {
+	models.NotificationSendHistory `json:",inline"`
+	BodyMarkdown                   string `json:"body_markdown,omitempty"`
+}
+
 const (
 	toolGetNotificationDetail       = "get_notification_detail"
 	toolGetNotificationsForResource = "get_notifications_for_resource"
@@ -43,16 +49,21 @@ func getNotificationDetailHandler(goctx gocontext.Context, req mcp.CallToolReque
 		return mcp.NewToolResultError(err.Error()), nil
 	}
 
-	var notification models.NotificationSendHistory
+	var history models.NotificationSendHistory
 	err = ctx.DB().
 		Table("notification_send_history_summary").
 		Where("id = ?", sendID).
-		First(&notification).Error
+		First(&history).Error
 	if err != nil {
 		return mcp.NewToolResultError(fmt.Sprintf("failed to get notification: %v", err)), nil
 	}
 
-	return structToMCPResponse(req, []models.NotificationSendHistory{notification}), nil
+	resp := notificationDetailResponse{
+		NotificationSendHistory: history,
+		BodyMarkdown:            notification.RenderBodyMarkdown(history),
+	}
+
+	return structToMCPResponse(req, []notificationDetailResponse{resp}), nil
 }
 
 func getNotificationsForResourceHandler(goctx gocontext.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -122,7 +133,7 @@ func parseDateMath(val string) (time.Time, error) {
 
 func registerNotifications(s *server.MCPServer) {
 	getNotificationDetailTool := mcp.NewTool(toolGetNotificationDetail,
-		mcp.WithDescription("Get detailed information about a specific notification including status, body, recipients, resource details, and related entities"),
+		mcp.WithDescription("Get detailed information about a specific notification including status, body_markdown (rendered body), recipients, resource details, and related entities"),
 		mcp.WithReadOnlyHintAnnotation(true),
 		mcp.WithString("send_id",
 			mcp.Required(),

notification/context.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/flanksource/duty/context"
 	"github.com/flanksource/duty/models"
+	"github.com/flanksource/duty/types"
 	"github.com/google/uuid"
 	"github.com/samber/lo"
 	"github.com/samber/oops"
@@ -55,6 +56,10 @@ func (t *Context) WithMessage(message string) {
 	t.log.Body = &message
 }
 
+func (t *Context) WithBodyPayload(payload types.JSON) {
+	t.log.BodyPayload = payload
+}
+
 func (t *Context) WithRecipient(recipientType RecipientType, id *uuid.UUID) {
 	t.recipientType = recipientType
 

notification/controllers.go

@@ -3,14 +3,17 @@ package notification
 import (
 	"encoding/json"
 	"net/http"
+	"strings"
 
 	"github.com/flanksource/duty/api"
 	"github.com/flanksource/duty/context"
 	"github.com/flanksource/duty/models"
 	"github.com/flanksource/duty/query"
 	"github.com/flanksource/duty/rbac/policy"
 	"github.com/flanksource/duty/types"
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
+	"gorm.io/gorm"
 
 	"github.com/flanksource/incident-commander/db"
 	echoSrv "github.com/flanksource/incident-commander/echo"
@@ -25,6 +28,7 @@ func RegisterRoutes(e *echo.Echo) {
 	g := e.Group("/notification")
 
 	g.POST("/summary", NotificationSendHistorySummary, echoSrv.RLSMiddleware)
+	g.GET("/send_history/:id", GetNotificationSendHistoryDetail, echoSrv.RLSMiddleware)
 
 	g.GET("/events", func(c echo.Context) error {
 		return c.JSON(http.StatusOK, EventRing.Get())
@@ -67,9 +71,41 @@ func NotificationSendHistorySummary(c echo.Context) error {
 	return c.JSON(http.StatusOK, response)
 }
 
+func GetNotificationSendHistoryDetail(c echo.Context) error {
+	ctx := c.Request().Context().(context.Context)
+	id := c.Param("id")
+	if _, err := uuid.Parse(id); err != nil {
+		return api.WriteError(c, api.Errorf(api.EINVALID, "invalid notification history id: %s", id))
+	}
+
+	var detail NotificationSendHistoryDetail
+	if err := ctx.DB().Model(&models.NotificationSendHistory{}).Where("id = ?", id).First(&detail.NotificationSendHistory).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return api.WriteError(c, api.Errorf(api.ENOTFOUND, "notification history %s not found", id))
+		}
+		return api.WriteError(c, ctx.Oops().Wrap(err))
+	}
+
+	resourceKind := strings.Split(detail.SourceEvent, ".")[0]
+	detail.ResourceKind = resourceKind
+	if resourceMap, err := GetResourceAsMapFromEvent(ctx, detail.SourceEvent, detail.ResourceID.String()); err == nil && resourceMap != nil {
+		if b, err := json.Marshal(resourceMap); err == nil {
+			detail.Resource = types.JSON(b)
+		}
+		if resourceType, ok := resourceMap["type"].(string); ok && resourceType != "" {
+			detail.ResourceType = &resourceType
+		}
+	}
+
+	detail.BodyMarkdown = RenderBodyMarkdown(detail.NotificationSendHistory)
+
+	return c.JSON(http.StatusOK, detail)
+}
+
 type NotificationSilencePreviewItem struct {
 	models.NotificationSendHistory `json:",inline"`
 	Resource                       map[string]any `json:"resource"`
+	BodyMarkdown                   string         `json:"body_markdown,omitempty"`
 }
 
 func NotificationSilencePreview(c echo.Context) error {
@@ -105,10 +141,13 @@ func NotificationSilencePreview(c echo.Context) error {
 		if err != nil {
 			return api.WriteError(c, err)
 		}
-		resp = append(resp, NotificationSilencePreviewItem{
+
+		item := NotificationSilencePreviewItem{
 			NotificationSendHistory: s,
 			Resource:                rMap,
-		})
+		}
+		item.BodyMarkdown = RenderBodyMarkdown(s)
+		resp = append(resp, item)
 	}
 
 	return c.JSON(200, resp)

notification/events.go

@@ -274,6 +274,10 @@ func addNotificationEvent(ctx context.Context, id string, celEnv *celVariables,
 		if blocker, err := processNotificationConstraints(ctx, *n, payload, celEnv, matchingSilences); err != nil {
 			return fmt.Errorf("failed to check all conditions for notification[%s]: %w", n.ID, err)
 		} else if blocker != nil {
+			body, bodyPayload, err := buildNotificationHistoryPayload(ctx, payload, n, celEnv)
+			if err != nil {
+				return err
+			}
 			history := models.NotificationSendHistory{
 				NotificationID:            n.ID,
 				ResourceID:                payload.ID,
@@ -288,7 +292,8 @@ func addNotificationEvent(ctx context.Context, id string, celEnv *celVariables,
 				PersonID:                  payload.PersonID,
 				TeamID:                    payload.TeamID,
 				ConnectionID:              payload.Connection,
-				Body:                      payload.Body,
+				Body:                      body,
+				BodyPayload:               bodyPayload,
 			}
 
 			if err := db.SaveUnsentNotificationToHistory(ctx, history); err != nil {
@@ -309,6 +314,10 @@ func addNotificationEvent(ctx context.Context, id string, celEnv *celVariables,
 		// Notifications that have waitFor configured go through a waiting stage
 		// while the rest are sent immediately.
 		if n.WaitFor != nil {
+			body, bodyPayload, err := buildNotificationHistoryPayload(ctx, payload, n, celEnv)
+			if err != nil {
+				return err
+			}
 			pendingHistory := models.NotificationSendHistory{
 				NotificationID:            n.ID,
 				ResourceID:                payload.ID,
@@ -323,7 +332,8 @@ func addNotificationEvent(ctx context.Context, id string, celEnv *celVariables,
 				PersonID:                  payload.PersonID,
 				ConnectionID:              payload.Connection,
 				TeamID:                    payload.TeamID,
-				Body:                      payload.Body,
+				Body:                      body,
+				BodyPayload:               bodyPayload,
 			}
 
 			if err := ctx.DB().Create(&pendingHistory).Error; err != nil {
@@ -343,6 +353,66 @@ func addNotificationEvent(ctx context.Context, id string, celEnv *celVariables,
 	return nil
 }
 
+func buildNotificationHistoryPayload(ctx context.Context, payload NotificationEventPayload, notification *NotificationWithSpec, celEnv *celVariables) (*string, types.JSON, error) {
+	if celEnv == nil || notification == nil {
+		return nil, nil, nil
+	}
+
+	if strings.TrimSpace(notification.Template) != "" {
+		msg, err := getNotificationMsg(ctx, celEnv, payload, notification)
+		if err != nil {
+			return nil, nil, err
+		}
+		return lo.ToPtr(msg.Message), nil, nil
+	}
+
+	env := *celEnv
+	if payload.GroupID != nil {
+		groupedResources, err := db.GetGroupedResources(ctx, *payload.GroupID, payload.ID.String())
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to get grouped resources for notification[%s]: %w", payload.NotificationID, err)
+		}
+		env.GroupedResources = groupedResources
+	}
+
+	msgPayload := BuildNotificationMessagePayload(payload, &env)
+	applyTemplateOverrides(NewContext(ctx, payload.NotificationID), &msgPayload, notification, &env)
+	bodyPayload, err := json.Marshal(msgPayload)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to marshal notification payload: %w", err)
+	}
+
+	return nil, types.JSON(bodyPayload), nil
+}
+
+// getNotificationMsg renders a notification message when a custom template is provided.
+// It uses clicky-generated defaults for the title if no custom title is specified.
+func getNotificationMsg(ctx context.Context, celEnv *celVariables, payload NotificationEventPayload, n *NotificationWithSpec) (*NotificationTemplate, error) {
+	defaultTitle, defaultBody := DefaultTitleAndBody(payload, celEnv)
+	data := NotificationTemplate{
+		Title:      lo.CoalesceOrEmpty(n.Title, defaultTitle),
+		Message:    lo.CoalesceOrEmpty(n.Template, defaultBody),
+		Properties: n.Properties,
+	}
+	templater := ctx.NewStructTemplater(celEnv.AsMap(ctx), "", TemplateFuncs)
+	if err := templater.Walk(&data); err != nil {
+		return nil, fmt.Errorf("error templating notification: %w", err)
+	}
+
+	if strings.Contains(data.Message, `"blocks"`) {
+		var slackMsg SlackMsgTemplate
+		if err := json.Unmarshal([]byte(data.Message), &slackMsg); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal slack template into blocks: %w", err)
+		}
+
+		if b, err := json.Marshal([]any{slackMsg}); err == nil {
+			data.Message = string(b)
+		}
+	}
+
+	return &data, nil
+}
+
 type validateResult struct {
 	BlockedWithStatus string
 	ParentID          *uuid.UUID