Add listing all contact points with limits (#81)

Author: sunwupark

testdata/provisioning/alerting/contact_points.yaml

@@ -0,0 +1,19 @@
+apiVersion: 1
+
+contactPoints:
+  - name: Email1
+    receivers:
+      - uid: email1
+        type: email
+        settings:
+          addresses: [email protected]
+          singleEmail: false
+          message: my optional message1 to include
+  - name: Email2
+    receivers:
+      - uid: email2
+        type: email
+        settings:
+          addresses: [email protected]
+          singleEmail: false
+          message: my optional message2 to include

tools/alerting.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/grafana/grafana-openapi-client-go/client/provisioning"
 	"github.com/grafana/grafana-openapi-client-go/models"
 	"github.com/mark3labs/mcp-go/server"
 	"github.com/prometheus/prometheus/model/labels"
@@ -12,7 +13,8 @@ import (
 )
 
 const (
-	DefaultListAlertRulesLimit = 100
+	DefaultListAlertRulesLimit    = 100
+	DefaultListContactPointsLimit = 100
 )
 
 type ListAlertRulesParams struct {
@@ -179,7 +181,81 @@ var GetAlertRuleByUID = mcpgrafana.MustTool(
 	getAlertRuleByUID,
 )
 
+type ListContactPointsParams struct {
+	Limit int     `json:"limit,omitempty" jsonschema:"description=The maximum number of results to return. Default is 100."`
+	Name  *string `json:"name,omitempty" jsonschema:"description=Filter contact points by name"`
+}
+
+func (p ListContactPointsParams) validate() error {
+	if p.Limit < 0 {
+		return fmt.Errorf("invalid limit: %d, must be greater than 0", p.Limit)
+	}
+	return nil
+}
+
+type contactPointSummary struct {
+	UID  string  `json:"uid"`
+	Name string  `json:"name"`
+	Type *string `json:"type,omitempty"`
+}
+
+func listContactPoints(ctx context.Context, args ListContactPointsParams) ([]contactPointSummary, error) {
+	if err := args.validate(); err != nil {
+		return nil, fmt.Errorf("list contact points: %w", err)
+	}
+
+	c := mcpgrafana.GrafanaClientFromContext(ctx)
+
+	params := provisioning.NewGetContactpointsParams().WithContext(ctx)
+	if args.Name != nil {
+		params.Name = args.Name
+	}
+
+	response, err := c.Provisioning.GetContactpoints(params)
+	if err != nil {
+		return nil, fmt.Errorf("list contact points: %w", err)
+	}
+
+	filteredContactPoints, err := applyLimitToContactPoints(response.Payload, args.Limit)
+	if err != nil {
+		return nil, fmt.Errorf("list contact points: %w", err)
+	}
+
+	return summarizeContactPoints(filteredContactPoints), nil
+}
+
+func summarizeContactPoints(contactPoints []*models.EmbeddedContactPoint) []contactPointSummary {
+	result := make([]contactPointSummary, 0, len(contactPoints))
+	for _, cp := range contactPoints {
+		result = append(result, contactPointSummary{
+			UID:  cp.UID,
+			Name: cp.Name,
+			Type: cp.Type,
+		})
+	}
+	return result
+}
+
+func applyLimitToContactPoints(items []*models.EmbeddedContactPoint, limit int) ([]*models.EmbeddedContactPoint, error) {
+	if limit == 0 {
+		limit = DefaultListContactPointsLimit
+	}
+
+	if limit > len(items) {
+		return items, nil
+	}
+
+	return items[:limit], nil
+}
+
+var ListContactPoints = mcpgrafana.MustTool(
+	"list_contact_points",
+	"List contact points",
+	listContactPoints,
+)
+
 func AddAlertingTools(mcp *server.MCPServer) {
 	ListAlertRules.Register(mcp)
 	GetAlertRuleByUID.Register(mcp)
+	ListContactPoints.Register(mcp)
 }

tools/alerting_test.go

@@ -399,3 +399,85 @@ func TestAlertingTools_GetAlertRuleByUID(t *testing.T) {
 		require.Contains(t, err.Error(), "getAlertRuleNotFound")
 	})
 }
+
+var (
+	emailType = "email"
+
+	contactPoint1 = contactPointSummary{
+		UID:  "email1",
+		Name: "Email1",
+		Type: &emailType,
+	}
+	contactPoint2 = contactPointSummary{
+		UID:  "email2",
+		Name: "Email2",
+		Type: &emailType,
+	}
+	contactPoint3 = contactPointSummary{
+		UID:  "",
+		Name: "email receiver",
+		Type: &emailType,
+	}
+	allExpectedContactPoints = []contactPointSummary{contactPoint1, contactPoint2, contactPoint3}
+)
+
+func TestAlertingTools_ListContactPoints(t *testing.T) {
+	t.Run("list contact points", func(t *testing.T) {
+		ctx := newTestContext()
+		result, err := listContactPoints(ctx, ListContactPointsParams{})
+		require.NoError(t, err)
+		require.ElementsMatch(t, allExpectedContactPoints, result)
+	})
+
+	t.Run("list one contact point", func(t *testing.T) {
+		ctx := newTestContext()
+
+		// Get the contact points with limit 1
+		result1, err := listContactPoints(ctx, ListContactPointsParams{
+			Limit: 1,
+		})
+		require.NoError(t, err)
+		require.Len(t, result1, 1)
+	})
+
+	t.Run("list contact points with name filter", func(t *testing.T) {
+		ctx := newTestContext()
+		name := "Email1"
+
+		result, err := listContactPoints(ctx, ListContactPointsParams{
+			Name: &name,
+		})
+		require.NoError(t, err)
+		require.Len(t, result, 1)
+		require.Equal(t, "Email1", result[0].Name)
+	})
+
+	t.Run("list contact points with invalid limit parameter", func(t *testing.T) {
+		ctx := newTestContext()
+		result, err := listContactPoints(ctx, ListContactPointsParams{
+			Limit: -1,
+		})
+		require.Error(t, err)
+		require.Empty(t, result)
+	})
+
+	t.Run("list contact points with large limit", func(t *testing.T) {
+		ctx := newTestContext()
+		result, err := listContactPoints(ctx, ListContactPointsParams{
+			Limit: 1000,
+		})
+		require.NoError(t, err)
+		require.NotEmpty(t, result)
+	})
+
+	t.Run("list contact points with non-existent name filter", func(t *testing.T) {
+		ctx := newTestContext()
+		name := "NonExistentAlert"
+
+		result, err := listContactPoints(ctx, ListContactPointsParams{
+			Name: &name,
+		})
+		require.NoError(t, err)
+		require.Empty(t, result)
+	})
+}