refactor(tools): cap window at 90d, guard TimeWindow methods on zero, and expand test coverage

Author: dangaiden

internal/infra/mcp/tools/tool_k8s_list_top_http_errors_in_pods_test.go

@@ -160,4 +160,45 @@ var _ = Describe("KubernetesListTopHttpErrorsInPods Tool", func() {
 			Expect(result.Content[0].(mcp.TextContent).Text).To(ContainSubstring("invalid interval format"))
 		})
 	})
+
+	When("the time window is invalid", func() {
+		It("rejects an unparseable start", func() {
+			serverTool := mcpServer.GetTool("k8s_list_top_http_errors_in_pods")
+			result, err := serverTool.Handler(ctx, mcp.CallToolRequest{
+				Params: mcp.CallToolParams{
+					Name:      "k8s_list_top_http_errors_in_pods",
+					Arguments: map[string]any{"start": "not-a-timestamp"},
+				},
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.IsError).To(BeTrue())
+		})
+
+		It("rejects an end before start", func() {
+			serverTool := mcpServer.GetTool("k8s_list_top_http_errors_in_pods")
+			result, err := serverTool.Handler(ctx, mcp.CallToolRequest{
+				Params: mcp.CallToolParams{
+					Name: "k8s_list_top_http_errors_in_pods",
+					Arguments: map[string]any{
+						"start": "2026-04-16T11:00:00Z",
+						"end":   "2026-04-16T10:00:00Z",
+					},
+				},
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.IsError).To(BeTrue())
+		})
+
+		It("rejects an end provided without start", func() {
+			serverTool := mcpServer.GetTool("k8s_list_top_http_errors_in_pods")
+			result, err := serverTool.Handler(ctx, mcp.CallToolRequest{
+				Params: mcp.CallToolParams{
+					Name:      "k8s_list_top_http_errors_in_pods",
+					Arguments: map[string]any{"end": "2026-04-16T11:00:00Z"},
+				},
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.IsError).To(BeTrue())
+		})
+	})
 })

internal/infra/mcp/tools/utils.go

@@ -59,9 +59,10 @@ func RequiredPermissionsFromTool(tool mcp.Tool) []string {
 
 const (
 	windowedQueryTimeout  = "60s"
+	maxWindowDuration     = 90 * 24 * time.Hour
 	timeParamStart        = "start"
 	timeParamEnd          = "end"
-	startParamDescription = "Start of the query window as an RFC3339 timestamp (e.g. 2026-04-01T00:00:00Z). When omitted, the tool returns an instant snapshot (current behavior). When provided without end, end defaults to now."
+	startParamDescription = "Start of the query window as an RFC3339 timestamp (e.g. 2026-04-01T00:00:00Z). When omitted, the tool returns an instant snapshot (current behavior). When provided without end, end defaults to now. The window between start and end may not exceed 90 days."
 	endParamDescription   = "End of the query window as an RFC3339 timestamp (e.g. 2026-04-01T01:00:00Z). Requires start. If in the future, clamped to now."
 )
 
@@ -75,10 +76,16 @@ func (w TimeWindow) IsZero() bool {
 }
 
 func (w TimeWindow) RangeSelector() string {
+	if w.IsZero() {
+		panic("RangeSelector called on zero TimeWindow")
+	}
 	return fmt.Sprintf("[%ds]", int64(w.End.Sub(w.Start).Seconds()))
 }
 
 func (w TimeWindow) WindowSeconds() int64 {
+	if w.IsZero() {
+		panic("WindowSeconds called on zero TimeWindow")
+	}
 	return int64(w.End.Sub(w.Start).Seconds())
 }
 
@@ -94,15 +101,16 @@ func (w TimeWindow) EvalTime() (*sysdig.Time, error) {
 }
 
 func (w TimeWindow) ApplyToParams(params *sysdig.GetQueryV1Params) error {
+	if w.IsZero() {
+		return nil
+	}
 	evalTime, err := w.EvalTime()
 	if err != nil {
 		return err
 	}
 	params.Time = evalTime
-	if !w.IsZero() {
-		timeout := sysdig.Timeout(windowedQueryTimeout)
-		params.Timeout = &timeout
-	}
+	timeout := sysdig.Timeout(windowedQueryTimeout)
+	params.Timeout = &timeout
 	return nil
 }
 
@@ -114,7 +122,6 @@ func WithTimeWindowParams() mcp.ToolOption {
 }
 
 // Reads "start" and "end" from the request, validates them, and return the resolved TimeWindow.
-
 func ParseTimeWindow(request mcp.CallToolRequest, clk clock.Clock) (TimeWindow, error) {
 	startStr := mcp.ParseString(request, timeParamStart, "")
 	endStr := mcp.ParseString(request, timeParamEnd, "")
@@ -150,6 +157,10 @@ func ParseTimeWindow(request mcp.CallToolRequest, clk clock.Clock) (TimeWindow,
 		return TimeWindow{}, fmt.Errorf("end (%s) must be after start (%s)", end.Format(time.RFC3339), start.Format(time.RFC3339))
 	}
 
+	if end.Sub(start) > maxWindowDuration {
+		return TimeWindow{}, fmt.Errorf("window between start (%s) and end (%s) exceeds the maximum of 90 days", start.Format(time.RFC3339), end.Format(time.RFC3339))
+	}
+
 	return TimeWindow{Start: start, End: end}, nil
 }
 

internal/infra/mcp/tools/utils_test.go

@@ -10,6 +10,7 @@ import (
 
 	mocks_clock "github.com/sysdiglabs/sysdig-mcp-server/internal/infra/clock/mocks"
 	"github.com/sysdiglabs/sysdig-mcp-server/internal/infra/mcp/tools"
+	"github.com/sysdiglabs/sysdig-mcp-server/internal/infra/sysdig"
 )
 
 var _ = Describe("ParseTimeWindow", func() {
@@ -101,11 +102,92 @@ var _ = Describe("ParseTimeWindow", func() {
 		Expect(tw.End).To(Equal(time.Date(2026, time.April, 16, 11, 0, 0, 0, time.UTC)))
 	})
 
-	It("truncates sub-second precision from now so RangeSelector never emits [0s]", func() {
+	It("rejects start at or after the truncated current second (end is not after start)", func() {
 		mockClock.EXPECT().Now().Return(now)
 		_, err := tools.ParseTimeWindow(makeRequest(map[string]any{
 			"start": "2026-04-16T12:00:00Z",
 		}), mockClock)
-		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(ContainSubstring("must be after start")))
+	})
+
+	It("rejects windows longer than 90 days", func() {
+		mockClock.EXPECT().Now().Return(now)
+		_, err := tools.ParseTimeWindow(makeRequest(map[string]any{
+			"start": "2026-01-01T00:00:00Z",
+			"end":   "2026-04-30T00:00:00Z",
+		}), mockClock)
+		Expect(err).To(MatchError(ContainSubstring("exceeds the maximum of 90 days")))
+	})
+
+	It("accepts windows of exactly 90 days", func() {
+		mockClock.EXPECT().Now().Return(now)
+		_, err := tools.ParseTimeWindow(makeRequest(map[string]any{
+			"start": "2026-01-01T00:00:00Z",
+			"end":   "2026-04-01T00:00:00Z",
+		}), mockClock)
+		Expect(err).NotTo(HaveOccurred())
+	})
+})
+
+var _ = Describe("TimeWindow methods", func() {
+	var (
+		start = time.Date(2026, time.April, 16, 10, 0, 0, 0, time.UTC)
+		end   = time.Date(2026, time.April, 16, 11, 0, 0, 0, time.UTC)
+		tw    = tools.TimeWindow{Start: start, End: end}
+	)
+
+	Describe("RangeSelector", func() {
+		It("returns the PromQL range-selector literal in seconds for a 1h window", func() {
+			Expect(tw.RangeSelector()).To(Equal("[3600s]"))
+		})
+
+		It("panics when called on a zero TimeWindow", func() {
+			Expect(func() { tools.TimeWindow{}.RangeSelector() }).To(PanicWith("RangeSelector called on zero TimeWindow"))
+		})
+	})
+
+	Describe("WindowSeconds", func() {
+		It("returns the window length in whole seconds for a 1h window", func() {
+			Expect(tw.WindowSeconds()).To(Equal(int64(3600)))
+		})
+
+		It("panics when called on a zero TimeWindow", func() {
+			Expect(func() { tools.TimeWindow{}.WindowSeconds() }).To(PanicWith("WindowSeconds called on zero TimeWindow"))
+		})
+	})
+
+	Describe("EvalTime", func() {
+		It("returns nil eval time for a zero TimeWindow", func() {
+			et, err := tools.TimeWindow{}.EvalTime()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(et).To(BeNil())
+		})
+
+		It("returns a sysdig.Time encoding the window's End for a non-zero window", func() {
+			et, err := tw.EvalTime()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(et).NotTo(BeNil())
+
+			var expected sysdig.Time
+			Expect(expected.FromQueryTime1(end.Unix())).To(Succeed())
+			Expect(*et).To(Equal(expected))
+		})
+	})
+
+	Describe("ApplyToParams", func() {
+		It("leaves params untouched on a zero TimeWindow", func() {
+			params := &sysdig.GetQueryV1Params{}
+			Expect(tools.TimeWindow{}.ApplyToParams(params)).To(Succeed())
+			Expect(params.Time).To(BeNil())
+			Expect(params.Timeout).To(BeNil())
+		})
+
+		It("sets Time and Timeout for a non-zero window", func() {
+			params := &sysdig.GetQueryV1Params{}
+			Expect(tw.ApplyToParams(params)).To(Succeed())
+			Expect(params.Time).NotTo(BeNil())
+			Expect(params.Timeout).NotTo(BeNil())
+			Expect(*params.Timeout).To(Equal(sysdig.Timeout("60s")))
+		})
 	})
 })