From 6ba80e70b114dd64b641cf2b30206b95af1eb47a Mon Sep 17 00:00:00 2001 From: Belal Taher Date: Wed, 18 Nov 2026 14:37:29 -0500 Subject: [PATCH 1/3] Add secret scanning alert update tool Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- README.md | 11 + cmd/github-mcp-server/main_test.go | 19 + .../update_secret_scanning_alert.snap | 134 +++++++ pkg/github/tools.go | 1 + pkg/github/typed_security_outputs_test.go | 2 + pkg/github/update_secret_scanning_alert.go | 210 +++++++++++ .../update_secret_scanning_alert_test.go | 335 ++++++++++++++++++ .../skills/security-alert-triage/SKILL.md | 22 +- .../references/alert-sources.md | 9 +- pkg/skills/catalog/tools.go | 2 +- 10 files changed, 739 insertions(+), 6 deletions(-) create mode 100644 pkg/github/__toolsnaps__/update_secret_scanning_alert.snap create mode 100644 pkg/github/update_secret_scanning_alert.go create mode 100644 pkg/github/update_secret_scanning_alert_test.go diff --git a/README.md b/README.md index c9f503d66b..b2c9a2db80 100644 --- a/README.md +++ b/README.md @@ -1614,6 +1614,17 @@ For negotiated supported protocol versions `2026-07-28` or newer, the consolidat - `secret_type`: A comma-separated list of secret types to return. All default secret patterns are returned. To return generic patterns, pass the token name(s) in the parameter. (string, optional) - `state`: Filter by state (string, optional) +- **update_secret_scanning_alert** - Update secret scanning alert + - **OAuth Challenge Scopes**: `security_events` + - `alertNumber`: Secret scanning alert number. (integer, required) + - `assignee`: Username with repository write access; null unassigns. (string | null, optional) + - `owner`: Repository owner. (string, required) + - `repo`: Repository name. (string, required) + - `resolution`: Reason for resolving. Non-null when state is resolved. (string | null, optional) + - `resolution_comment`: Optional comment when closing or reopening; cannot later be updated or deleted. (string | null, optional) + - `state`: Reopen or resolve the alert. (string, optional) + - `validity`: Manual validity override; null clears the override. (string | null, optional) +
diff --git a/cmd/github-mcp-server/main_test.go b/cmd/github-mcp-server/main_test.go index 0bc797f7ba..e064236582 100644 --- a/cmd/github-mcp-server/main_test.go +++ b/cmd/github-mcp-server/main_test.go @@ -108,6 +108,25 @@ func TestCodeScanningUpdateListScopes(t *testing.T) { } } +func TestSecretScanningUpdateListScopes(t *testing.T) { + for _, readOnly := range []bool{false, true} { + inv, err := github.NewInventory(translations.NullTranslationHelper). + WithToolsets([]string{"secret_protection"}).WithReadOnly(readOnly).Build() + require.NoError(t, err) + output := collectToolScopes(inv, readOnly) + if readOnly { + assert.NotContains(t, output.ScopesByTool, "update_secret_scanning_alert") + continue + } + assert.Equal(t, []string{"security_events"}, output.ScopesByTool["update_secret_scanning_alert"]) + assert.Contains(t, output.ToolsByScope["security_events"], "update_secret_scanning_alert") + assert.Contains(t, output.Tools, ToolScopeInfo{ + Name: "update_secret_scanning_alert", Toolset: "secret_protection", + ReadOnly: false, ChallengeScopes: []string{"security_events"}, + }) + } +} + func TestSchemaTypeString(t *testing.T) { tests := []struct { name string diff --git a/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap b/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap new file mode 100644 index 0000000000..e430ff2488 --- /dev/null +++ b/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap @@ -0,0 +1,134 @@ +{ + "annotations": { + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true, + "readOnlyHint": false, + "title": "Update secret scanning alert" + }, + "description": "Update a secret scanning alert's state, assignee, or validity override. Provide at least one of state, assignee, or validity. Resolving requires a non-null resolution. Omitted fields are unchanged; null unassigns the assignee or clears the validity override. Resolution comments accompany closing or reopening and cannot later be edited or deleted. Resolution revoked does not revoke credentials; validity is a manual override, not a validation request. Requires repository secret scanning write access. Delegated dismissal may require Secret scanning alert dismissal requests write permission and an authorized reviewer; API policy failures are returned without bypass.", + "inputSchema": { + "additionalProperties": false, + "properties": { + "alertNumber": { + "description": "Secret scanning alert number.", + "minimum": 1, + "type": "integer" + }, + "assignee": { + "description": "Username with repository write access; null unassigns.", + "type": [ + "string", + "null" + ] + }, + "owner": { + "description": "Repository owner.", + "minLength": 1, + "type": "string" + }, + "repo": { + "description": "Repository name.", + "minLength": 1, + "type": "string" + }, + "resolution": { + "description": "Reason for resolving. Non-null when state is resolved.", + "enum": [ + "false_positive", + "wont_fix", + "revoked", + "used_in_tests", + null + ], + "type": [ + "string", + "null" + ] + }, + "resolution_comment": { + "description": "Optional comment when closing or reopening; cannot later be updated or deleted.", + "type": [ + "string", + "null" + ] + }, + "state": { + "description": "Reopen or resolve the alert.", + "enum": [ + "open", + "resolved" + ], + "type": "string" + }, + "validity": { + "description": "Manual validity override; null clears the override.", + "enum": [ + "active", + "inactive", + null + ], + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "owner", + "repo", + "alertNumber" + ], + "type": "object" + }, + "name": "update_secret_scanning_alert", + "outputSchema": { + "additionalProperties": false, + "properties": { + "assigned_to": { + "additionalProperties": false, + "properties": { + "login": { + "type": "string" + } + }, + "required": [ + "login" + ], + "type": [ + "null", + "object" + ] + }, + "number": { + "description": "Exact alert number as a decimal string to preserve integer precision.", + "type": "string" + }, + "resolution": { + "type": [ + "null", + "string" + ] + }, + "state": { + "type": "string" + }, + "validity": { + "type": [ + "null", + "string" + ] + } + }, + "required": [ + "number", + "state", + "resolution", + "assigned_to" + ], + "type": [ + "null", + "object" + ] + } +} \ No newline at end of file diff --git a/pkg/github/tools.go b/pkg/github/tools.go index 46a6d7fc38..6a0a262175 100644 --- a/pkg/github/tools.go +++ b/pkg/github/tools.go @@ -328,6 +328,7 @@ func AllTools(t translations.TranslationHelperFunc, opts ...ToolOption) []invent // Secret protection tools GetSecretScanningAlert(t), ListSecretScanningAlerts(t), + UpdateSecretScanningAlert(t), // Dependabot tools GetDependabotAlert(t), diff --git a/pkg/github/typed_security_outputs_test.go b/pkg/github/typed_security_outputs_test.go index ab1b5831dc..c618b08499 100644 --- a/pkg/github/typed_security_outputs_test.go +++ b/pkg/github/typed_security_outputs_test.go @@ -32,6 +32,8 @@ func securityOutputSchema(t *testing.T, name string) *jsonschema.Schema { schema, err = jsonschema.For[[]*CodeScanningAlertOutput](nil) case "get_secret_scanning_alert": schema, err = jsonschema.For[*SecretScanningAlertOutput](nil) + case "update_secret_scanning_alert": + schema, err = jsonschema.For[*SecretScanningAlertUpdateOutput](nil) case "list_secret_scanning_alerts": schema, err = jsonschema.For[[]*SecretScanningAlertOutput](nil) case "get_dependabot_alert": diff --git a/pkg/github/update_secret_scanning_alert.go b/pkg/github/update_secret_scanning_alert.go new file mode 100644 index 0000000000..f368d731c2 --- /dev/null +++ b/pkg/github/update_secret_scanning_alert.go @@ -0,0 +1,210 @@ +package github + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "net/http" + "net/url" + "slices" + "strconv" + "strings" + "unicode" + + ghErrors "github.com/github/github-mcp-server/v2/pkg/errors" + "github.com/github/github-mcp-server/v2/pkg/ifc" + "github.com/github/github-mcp-server/v2/pkg/inventory" + "github.com/github/github-mcp-server/v2/pkg/scopes" + "github.com/github/github-mcp-server/v2/pkg/translations" + "github.com/github/github-mcp-server/v2/pkg/utils" + "github.com/google/go-github/v92/github" + "github.com/google/jsonschema-go/jsonschema" + "github.com/modelcontextprotocol/go-sdk/mcp" +) + +type UpdateSecretScanningAlertInput struct { + SecretScanningAlertPatch + Owner string `json:"owner"` + Repo string `json:"repo"` + AlertNumber int64 `json:"alertNumber"` +} + +// RawMessage distinguishes an omitted field from an explicit JSON null. +type SecretScanningAlertPatch struct { + State *string `json:"state,omitempty"` + Resolution json.RawMessage `json:"resolution,omitempty"` + ResolutionComment json.RawMessage `json:"resolution_comment,omitempty"` + Assignee json.RawMessage `json:"assignee,omitempty"` + Validity json.RawMessage `json:"validity,omitempty"` +} + +type SecretScanningAlertUpdateOutput struct { + Number string `json:"number" jsonschema:"Exact alert number as a decimal string to preserve integer precision."` + State string `json:"state"` + Resolution *string `json:"resolution"` + AssignedTo *SecretScanningAlertAssignee `json:"assigned_to"` + Validity *string `json:"validity,omitempty"` +} + +type SecretScanningAlertAssignee struct { + Login string `json:"login"` +} + +func UpdateSecretScanningAlert(t translations.TranslationHelperFunc) inventory.ServerTool { + return NewTool( + ToolsetMetadataSecretProtection, + mcp.Tool{ + Name: "update_secret_scanning_alert", + Description: t("TOOL_UPDATE_SECRET_SCANNING_ALERT_DESCRIPTION", + "Update a secret scanning alert's state, assignee, or validity override. "+ + "Provide at least one of state, assignee, or validity. Resolving requires a non-null resolution. "+ + "Omitted fields are unchanged; null unassigns the assignee or clears the validity override. "+ + "Resolution comments accompany closing or reopening and cannot later be edited or deleted. "+ + "Resolution revoked does not revoke credentials; validity is a manual override, not a validation request. "+ + "Requires repository secret scanning write access. Delegated dismissal may require Secret scanning alert dismissal requests write permission and an authorized reviewer; API policy failures are returned without bypass."), + Annotations: &mcp.ToolAnnotations{ + Title: t("TOOL_UPDATE_SECRET_SCANNING_ALERT_USER_TITLE", "Update secret scanning alert"), + ReadOnlyHint: false, + DestructiveHint: new(true), + OpenWorldHint: new(true), + }, + InputSchema: &jsonschema.Schema{ + Type: "object", + AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}}, + Properties: map[string]*jsonschema.Schema{ + "owner": {Type: "string", MinLength: new(1), Description: "Repository owner."}, + "repo": {Type: "string", MinLength: new(1), Description: "Repository name."}, + "alertNumber": {Type: "integer", Minimum: new(1.0), Description: "Secret scanning alert number."}, + "state": {Type: "string", Enum: []any{"open", "resolved"}, Description: "Reopen or resolve the alert."}, + "resolution": {Types: []string{"string", "null"}, Enum: []any{"false_positive", "wont_fix", "revoked", "used_in_tests", nil}, Description: "Reason for resolving. Non-null when state is resolved."}, + "resolution_comment": {Types: []string{"string", "null"}, Description: "Optional comment when closing or reopening; cannot later be updated or deleted."}, + "assignee": {Types: []string{"string", "null"}, Description: "Username with repository write access; null unassigns."}, + "validity": {Types: []string{"string", "null"}, Enum: []any{"active", "inactive", nil}, Description: "Manual validity override; null clears the override."}, + }, + Required: []string{"owner", "repo", "alertNumber"}, + }, + }, + scopes.RequireAll(scopes.SecurityEvents), + func(ctx context.Context, deps ToolDependencies, call *mcp.CallToolRequest, _ json.RawMessage) (*mcp.CallToolResult, *SecretScanningAlertUpdateOutput, error) { + // Typed schema validation passes through float64. Decode the original + // JSON so large IDs and fractional inputs cannot change the write target. + args, err := decodeSecretScanningAlertUpdate(call.Params.Arguments) + if err != nil { + return utils.NewToolResultErrorFromErr("invalid secret scanning alert update arguments", err), nil, nil + } + client, err := deps.GetClient(ctx) + if err != nil { + return utils.NewToolResultErrorFromErr("failed to get GitHub client", err), nil, err + } + path := fmt.Sprintf("repos/%s/%s/secret-scanning/alerts/%d", url.PathEscape(args.Owner), url.PathEscape(args.Repo), args.AlertNumber) + request, err := client.NewRequest(ctx, http.MethodPatch, path, args.SecretScanningAlertPatch, github.WithVersion("2026-03-10")) + if err != nil { + return utils.NewToolResultErrorFromErr("failed to create secret scanning alert update request", err), nil, err + } + var alert struct { + Number int64 `json:"number"` + State string `json:"state"` + Resolution *string `json:"resolution"` + AssignedTo *SecretScanningAlertAssignee `json:"assigned_to"` + Validity *string `json:"validity"` + } + resp, err := client.Do(request, &alert) + if resp != nil && resp.Body != nil { + defer func() { _ = resp.Body.Close() }() + } + if err != nil { + return ghErrors.NewGitHubAPIErrorResponse(ctx, "failed to update secret scanning alert", resp, err), nil, nil + } + if resp.StatusCode != http.StatusOK || alert.Number != args.AlertNumber || !slices.Contains([]string{"open", "resolved"}, alert.State) { + return utils.NewToolResultError("invalid secret scanning alert update response"), nil, nil + } + output := SecretScanningAlertUpdateOutput{ + Number: strconv.FormatInt(alert.Number, 10), State: alert.State, + Resolution: alert.Resolution, AssignedTo: alert.AssignedTo, Validity: alert.Validity, + } + encoded, err := json.Marshal(output) + if err != nil { + return utils.NewToolResultErrorFromErr("failed to marshal secret scanning alert update", err), nil, err + } + result := attachStaticIFCLabel(ctx, deps, utils.NewToolResultText(string(encoded)), ifc.LabelSecurityAlert()) + return result, &output, nil + }, + normalizeSecretScanningAlertUpdate, + ) +} + +func normalizeSecretScanningAlertUpdate(raw json.RawMessage) (json.RawMessage, error) { + if _, err := decodeSecretScanningAlertUpdate(raw); err != nil { + return nil, &inventory.ToolInputError{Message: err.Error()} + } + return raw, nil +} + +func decodeSecretScanningAlertUpdate(raw json.RawMessage) (UpdateSecretScanningAlertInput, error) { + var args UpdateSecretScanningAlertInput + var fields map[string]json.RawMessage + if err := json.Unmarshal(raw, &fields); err != nil { + return args, err + } + for name, value := range fields { + switch name { + case "resolution", "resolution_comment", "assignee", "validity": + continue + case "owner", "repo", "alertNumber", "state": + default: + return args, fmt.Errorf("unknown parameter: %s", name) + } + if bytes.Equal(bytes.TrimSpace(value), []byte("null")) { + return args, fmt.Errorf("parameter %s must not be null", name) + } + } + if err := json.Unmarshal(raw, &args); err != nil { + return args, err + } + for name, value := range map[string]string{"owner": args.Owner, "repo": args.Repo} { + if value == "" || value == "." || value == ".." || + strings.ContainsAny(value, `/\%?#`) || strings.ContainsFunc(value, func(r rune) bool { + return unicode.IsSpace(r) || unicode.IsControl(r) + }) { + return args, fmt.Errorf("%s must be a non-empty repository path segment", name) + } + } + if args.AlertNumber < 1 { + return args, errors.New("alertNumber must be a positive int64 integer") + } + if args.State == nil && len(args.Assignee) == 0 && len(args.Validity) == 0 { + return args, errors.New("provide state, assignee, or validity") + } + if args.State != nil && !slices.Contains([]string{"open", "resolved"}, *args.State) { + return args, errors.New("state must be open or resolved") + } + var resolution *string + if len(args.Resolution) != 0 { + if err := json.Unmarshal(args.Resolution, &resolution); err != nil { + return args, err + } + if resolution != nil && !slices.Contains([]string{"false_positive", "wont_fix", "revoked", "used_in_tests"}, *resolution) { + return args, errors.New("invalid resolution") + } + } + if args.State != nil && *args.State == "resolved" && resolution == nil { + return args, errors.New("a non-null resolution is required when state is resolved") + } + for name, raw := range map[string]json.RawMessage{ + "resolution_comment": args.ResolutionComment, "assignee": args.Assignee, "validity": args.Validity, + } { + if len(raw) == 0 { + continue + } + var value *string + if err := json.Unmarshal(raw, &value); err != nil { + return args, fmt.Errorf("invalid %s: %w", name, err) + } + if name == "validity" && value != nil && !slices.Contains([]string{"active", "inactive"}, *value) { + return args, errors.New("validity must be active, inactive, or null") + } + } + return args, nil +} diff --git a/pkg/github/update_secret_scanning_alert_test.go b/pkg/github/update_secret_scanning_alert_test.go new file mode 100644 index 0000000000..cc22d043b6 --- /dev/null +++ b/pkg/github/update_secret_scanning_alert_test.go @@ -0,0 +1,335 @@ +package github + +import ( + "context" + "encoding/json" + "fmt" + "io" + "maps" + "net/http" + "strings" + "testing" + + "github.com/github/github-mcp-server/v2/pkg/http/transport" + "github.com/github/github-mcp-server/v2/pkg/ifc" + "github.com/github/github-mcp-server/v2/pkg/inventory" + "github.com/github/github-mcp-server/v2/pkg/scopes" + "github.com/github/github-mcp-server/v2/pkg/translations" + "github.com/modelcontextprotocol/go-sdk/mcp" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func secretScanningUpdateSession(t *testing.T, handler http.HandlerFunc, protocol string, labels bool) (*mcp.ClientSession, *BaseDeps) { + t.Helper() + client := MockHTTPClientWithHandler(handler) + client.Transport = &transport.BearerAuthTransport{Transport: client.Transport, Token: "test-token"} + deps := &BaseDeps{Client: mustNewGHClient(t, client)} + if labels { + deps.featureChecker = featureCheckerFor(FeatureFlagIFCLabels) + } + server := mcp.NewServer(&mcp.Implementation{Name: "secret-scanning-update-test", Version: "1"}, nil) + server.AddReceivingMiddleware(InjectDepsMiddleware(deps)) + tool := UpdateSecretScanningAlert(translations.NullTranslationHelper) + tool.RegisterFunc(server, deps) + return connectCommentVisibilityClient(t, server, protocol), deps +} + +func TestUpdateSecretScanningAlert(t *testing.T) { + t.Parallel() + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + for _, tc := range []struct { + name, patch string + }{ + {"resolve false positive", `{"state":"resolved","resolution":"false_positive"}`}, + {"resolve wont fix", `{"state":"resolved","resolution":"wont_fix"}`}, + {"resolve revoked", `{"state":"resolved","resolution":"revoked"}`}, + {"resolve test secret", `{"state":"resolved","resolution":"used_in_tests"}`}, + {"reopen", `{"state":"open"}`}, + {"reopen with nulls", `{"state":"open","resolution":null,"resolution_comment":null}`}, + {"assign only", `{"assignee":"octocat"}`}, + {"unassign only", `{"assignee":null}`}, + {"active only", `{"validity":"active"}`}, + {"inactive only", `{"validity":"inactive"}`}, + {"clear override only", `{"validity":null}`}, + {"combined", `{"state":"resolved","resolution":"revoked","assignee":"octocat","validity":"inactive","resolution_comment":"rotated externally"}`}, + {"long comment", `{"state":"open","resolution_comment":"` + strings.Repeat("x", 281) + `"}`}, + {"empty comment", `{"state":"open","resolution_comment":""}`}, + } { + t.Run(protocol+"/"+tc.name, func(t *testing.T) { + t.Parallel() + var calls int + session, deps := secretScanningUpdateSession(t, func(w http.ResponseWriter, r *http.Request) { + calls++ + assert.Equal(t, "PATCH /repos/Octo/Widgets.name/secret-scanning/alerts/42", r.Method+" "+r.URL.Path) + assert.Empty(t, r.URL.RawQuery) + assert.Equal(t, "Bearer test-token", r.Header.Get("Authorization")) + assert.Equal(t, "2026-03-10", r.Header.Get("X-GitHub-Api-Version")) + body, err := io.ReadAll(r.Body) + require.NoError(t, err) + assert.JSONEq(t, tc.patch, string(body), "preserve omitted and null PATCH fields") + _, _ = io.WriteString(w, `{"number":42,"state":"open","resolution":null, + "assigned_to":{"login":"actual-owner","email":"not returned"}, + "validity":"unknown","secret":"must-not-appear","resolution_comment":"also not returned", + "metadata":[{"key":"sensitive","value":"not returned"}]}`) + }, protocol, true) + args := json.RawMessage(`{"owner":"Octo","repo":"Widgets.name","alertNumber":42,` + tc.patch[1:]) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: args}) + require.NoError(t, err) + require.False(t, result.IsError, "%+v", result.Content) + assert.Equal(t, 1, calls, "one PATCH, no fallback or policy preflight") + expected := `{"number":"42","state":"open","resolution":null,"assigned_to":{"login":"actual-owner"},"validity":"unknown"}` + assert.JSONEq(t, expected, getTextResult(t, result).Text, "return actual API state without secret-bearing fields") + if protocol == inventory.ProtocolVersionMultiRoundTrip { + require.NotNil(t, result.StructuredContent) + assert.JSONEq(t, expected, mustMarshalJSON(t, result.StructuredContent)) + } else { + assert.Nil(t, result.StructuredContent) + } + assert.JSONEq(t, mustMarshalJSON(t, ifc.LabelSecurityAlert()), mustMarshalJSON(t, result.Meta["ifc"])) + read, err := deps.Client.NewRequest(t.Context(), http.MethodGet, "repos/Octo/Widgets.name", nil) + require.NoError(t, err) + assert.Equal(t, "2022-11-28", read.Header.Get("X-GitHub-Api-Version"), "do not mutate the shared client's API version") + }) + } + t.Run(protocol+"/resolved without assignee or validity", func(t *testing.T) { + t.Parallel() + session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"number":42,"state":"resolved","resolution":"used_in_tests","assigned_to":null,"secret":"must-not-appear"}`) + }, protocol, false) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "assignee": nil, + }}) + require.NoError(t, err) + require.False(t, result.IsError, "%+v", result.Content) + expected := `{"number":"42","state":"resolved","resolution":"used_in_tests","assigned_to":null}` + assert.JSONEq(t, expected, getTextResult(t, result).Text) + assert.NotContains(t, result.Meta, "ifc") + if protocol == inventory.ProtocolVersionMultiRoundTrip { + assert.JSONEq(t, expected, mustMarshalJSON(t, result.StructuredContent)) + } + }) + } +} + +func TestUpdateSecretScanningAlertRejectsInvalidInput(t *testing.T) { + t.Parallel() + base := map[string]any{"owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "open"} + var inputs []json.RawMessage + for _, tc := range []struct { + field string + value any + }{ + {"owner", ""}, {"repo", ""}, {"owner", "../octo"}, {"repo", ".."}, {"repo", "."}, + {"owner", "octo/widgets"}, {"repo", "widgets/../../issues"}, {"repo", `widgets\repo`}, + {"owner", " octo"}, {"repo", "widgets "}, {"repo", "widgets\n"}, {"owner", "octo\u0000"}, + {"owner", "octo?x=y"}, {"repo", "widgets#fragment"}, {"repo", "%2e%2e"}, {"owner", "%252F"}, + {"owner", nil}, {"repo", nil}, {"alertNumber", 0}, {"alertNumber", -1}, {"alertNumber", 1.5}, + {"alertNumber", "42"}, {"alertNumber", 1e30}, {"alertNumber", nil}, + {"state", "closed"}, {"state", ""}, {"state", nil}, {"state", "resolved"}, + {"resolution", "pattern_edited"}, {"resolution", "pattern_deleted"}, {"resolution", ""}, {"resolution", "invalid"}, + {"resolution", false}, {"resolution", 7}, {"resolution_comment", 7}, {"resolution_comment", []string{"comment"}}, + {"assignee", []string{"octocat"}}, {"assignee", 7}, {"validity", "unknown"}, {"validity", ""}, {"validity", false}, + {"confirm", true}, {"secret", "no"}, {"create_request", true}, {"unexpected", true}, {"STATE", "resolved"}, + } { + args := maps.Clone(base) + args[tc.field] = tc.value + raw, err := json.Marshal(args) + require.NoError(t, err) + inputs = append(inputs, raw) + } + for _, patch := range []string{ + ``, `,"resolution_comment":"comment only"`, `,"resolution":"revoked"`, `,"resolution":null`, + `,"state":"resolved"`, `,"state":"resolved","resolution":null`, + `,"state":"resolved","resolution": null ,"assignee":null`, + } { + inputs = append(inputs, json.RawMessage(`{"owner":"octo","repo":"widgets","alertNumber":42`+patch+`}`)) + } + for _, field := range []string{"owner", "repo", "alertNumber"} { + args := maps.Clone(base) + delete(args, field) + raw, err := json.Marshal(args) + require.NoError(t, err) + inputs = append(inputs, raw) + } + inputs = append(inputs, json.RawMessage(`null`), json.RawMessage(`[]`)) + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + t.Run(protocol, func(t *testing.T) { + t.Parallel() + session, deps := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + t.Error("invalid input reached GitHub") + w.WriteHeader(http.StatusInternalServerError) + }, protocol, false) + tool := UpdateSecretScanningAlert(translations.NullTranslationHelper) + for _, raw := range inputs { + t.Run(string(raw), func(t *testing.T) { + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: tool.Tool.Name, Arguments: raw}) + require.NoError(t, err) + require.True(t, result.IsError, "%+v", result.Content) + assert.Nil(t, result.StructuredContent) + result, err = tool.Handler(deps)(ContextWithDeps(t.Context(), deps), &mcp.CallToolRequest{ + Params: &mcp.CallToolParamsRaw{Name: tool.Tool.Name, Arguments: raw}, + }) + require.NoError(t, err) + require.True(t, result.IsError, "%+v", result.Content) + }) + } + }) + } +} + +func TestUpdateSecretScanningAlertErrors(t *testing.T) { + t.Parallel() + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + for _, status := range []int{400, 403, 404, 409, 410, 422, 500, 503} { + t.Run(protocol+"/"+fmt.Sprint(status), func(t *testing.T) { + t.Parallel() + var calls int + session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + calls++ + w.WriteHeader(status) + _, _ = io.WriteString(w, `{"message":"delegated dismissal or update denied"}`) + }, protocol, true) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "resolved", "resolution": "revoked", + }}) + require.NoError(t, err) + require.True(t, result.IsError) + assert.Contains(t, getTextResult(t, result).Text, "delegated dismissal or update denied") + assert.Equal(t, 1, calls, "no fallback writes") + assert.Nil(t, result.StructuredContent) + assert.NotContains(t, result.Meta, "ifc") + }) + } + for _, response := range []string{ + `{`, `null`, `{}`, `{"number":42}`, `{"number":42,"state":null}`, + `{"number":42,"state":"invalid"}`, `{"number":42,"state":true}`, + `{"number":42,"state":"open","assigned_to":5}`, `{"number":43,"state":"open"}`, + } { + t.Run(protocol+"/"+response, func(t *testing.T) { + t.Parallel() + session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, response) + }, protocol, true) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "validity": nil, + }}) + require.NoError(t, err) + require.True(t, result.IsError) + assert.Nil(t, result.StructuredContent) + assert.NotContains(t, result.Meta, "ifc") + }) + } + t.Run(protocol+"/no content", func(t *testing.T) { + t.Parallel() + session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusNoContent) + }, protocol, false) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "open", + }}) + require.NoError(t, err) + require.True(t, result.IsError) + }) + } +} + +func TestUpdateSecretScanningAlertExactNumbers(t *testing.T) { + t.Parallel() + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + for _, number := range []string{"9007199254740993", "9223372036854775807", "9223372036854775808", "1.0000000000000000001", "9007199254740993.1", "42.000000000000000001", "1e-500"} { + t.Run(protocol+"/"+number, func(t *testing.T) { + t.Parallel() + valid := number == "9007199254740993" || number == "9223372036854775807" + var calls int + session, deps := secretScanningUpdateSession(t, func(w http.ResponseWriter, r *http.Request) { + calls++ + assert.True(t, valid, "invalid input must not reach GitHub") + assert.Equal(t, "/repos/octo/widgets/secret-scanning/alerts/"+number, r.URL.Path) + _, _ = fmt.Fprintf(w, `{"number":%s,"state":"open"}`, number) + }, protocol, false) + args := json.RawMessage(`{"owner":"octo","repo":"widgets","alertNumber":` + number + `,"state":"open"}`) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: args}) + require.NoError(t, err) + if !valid { + require.True(t, result.IsError) + assert.Zero(t, calls) + tool := UpdateSecretScanningAlert(translations.NullTranslationHelper) + result, err = tool.Handler(deps)(ContextWithDeps(t.Context(), deps), &mcp.CallToolRequest{ + Params: &mcp.CallToolParamsRaw{Name: tool.Tool.Name, Arguments: args}, + }) + require.NoError(t, err) + require.True(t, result.IsError) + assert.Zero(t, calls) + return + } + require.False(t, result.IsError, "%+v", result.Content) + assert.Equal(t, 1, calls) + var output struct { + Number string `json:"number"` + } + require.NoError(t, json.Unmarshal([]byte(getTextResult(t, result).Text), &output)) + assert.Equal(t, number, output.Number) + if protocol == inventory.ProtocolVersionMultiRoundTrip { + require.NoError(t, json.Unmarshal([]byte(mustMarshalJSON(t, result.StructuredContent)), &output)) + assert.Equal(t, number, output.Number) + } + }) + } + } +} + +func TestUpdateSecretScanningAlertInventoryAndSchema(t *testing.T) { + t.Parallel() + tool := UpdateSecretScanningAlert(translations.NullTranslationHelper) + testSecurityToolSnapshot(t, tool.Tool) + assert.Equal(t, ToolsetMetadataSecretProtection, tool.Toolset) + assert.Equal(t, scopes.RequireAll(scopes.SecurityEvents).Scopes, tool.ScopeAccess.Scopes) + assert.NotEmpty(t, tool.ScopeAccess.Challenge(map[string]any{}, nil)) + assert.False(t, tool.IsReadOnly()) + assert.True(t, *tool.Tool.Annotations.DestructiveHint) + for _, tc := range []struct { + name string + toolsets []string + readOnly bool + scopes []string + want bool + }{ + {"opt-in", []string{"secret_protection"}, false, []string{"security_events"}, true}, + {"default excludes", []string{"default"}, false, []string{"security_events"}, false}, + {"read-only excludes", []string{"secret_protection"}, true, []string{"security_events"}, false}, + {"missing scope excludes", []string{"secret_protection"}, false, []string{}, false}, + } { + t.Run(tc.name, func(t *testing.T) { + inv, err := NewInventory(translations.NullTranslationHelper). + WithToolsets(tc.toolsets).WithReadOnly(tc.readOnly). + WithFilter(CreateToolScopeFilter(tc.scopes)).Build() + require.NoError(t, err) + found := false + for _, candidate := range inv.AvailableTools(context.Background()) { + found = found || candidate.Tool.Name == tool.Tool.Name + } + assert.Equal(t, tc.want, found) + }) + } + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + session, _ := secretScanningUpdateSession(t, func(_ http.ResponseWriter, _ *http.Request) { + t.Error("listing tools must not call GitHub") + }, protocol, false) + listed, err := session.ListTools(t.Context(), nil) + require.NoError(t, err) + require.Len(t, listed.Tools, 1) + encoded := mustMarshalJSON(t, listed.Tools[0].InputSchema) + var schema map[string]json.RawMessage + require.NoError(t, json.Unmarshal([]byte(encoded), &schema)) + for _, keyword := range []string{"anyOf", "oneOf", "allOf", "if", "then", "else"} { + assert.NotContains(t, schema, keyword) + } + assert.NotContains(t, encoded, `"default"`) + if protocol == inventory.ProtocolVersionMultiRoundTrip { + assert.JSONEq(t, mustMarshalJSON(t, securityOutputSchema(t, tool.Tool.Name)), mustMarshalJSON(t, listed.Tools[0].OutputSchema)) + } else { + assert.Nil(t, listed.Tools[0].OutputSchema) + } + } +} diff --git a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md index c6216e6a65..bd5da2b104 100644 --- a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md +++ b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md @@ -13,6 +13,9 @@ When available, `update_dependabot_alert` can reopen or dismiss a Dependabot ale or replace its assignees. It does not merge a fix or revoke a credential. `update_code_scanning_alert` can reopen or dismiss a code scanning alert, request delegated dismissal, or replace its assignees when enabled and not read-only. +`update_secret_scanning_alert` can reopen or resolve a secret scanning alert, change +its assignee, or override its validity when enabled and not read-only. None of these +actions revokes or rotates a credential. ## Sequence @@ -78,8 +81,8 @@ outranks nothing; a moderate one on a public entry point may outrank everything. fields a dependency recommendation is built from. - `secret_type` — identifies what kind of credential leaked, which decides how it is revoked and who owns the revocation. -- `resolution` on a closed secret alert — `revoked` is the only value that means the - credential is dead. +- `resolution` on a closed secret alert — `revoked` records that someone marked it + revoked; it does not itself revoke the credential or prove that it is dead. ## Confirm before anything is acted on @@ -114,6 +117,21 @@ policy. Report the actual returned state and assignees, not presumed dismissal o approval. GitHub enforces permissions, policy and agentic Autofix eligibility; report errors without fallback or agent configuration. +For a requested secret scanning update, use `update_secret_scanning_alert` with +separate `owner`, `repo` and a positive integer `alertNumber`, plus at least one of +`state`, `assignee`, or `validity`. `state` is `open` or `resolved`; resolving requires +a non-null `resolution`: `false_positive`, `wont_fix`, `revoked`, or `used_in_tests`. +`pattern_edited` and `pattern_deleted` are not accepted update reasons. +Omitted fields stay unchanged. `resolution`, `resolution_comment`, `assignee`, and +`validity` accept null; null unassigns the assignee or clears the validity override. +A non-null assignee is a username with repository write access. Validity accepts +`active` or `inactive`; it is a manual override, not a request to validate a secret. +Resolution comments accompany closing or reopening and cannot later be edited or +deleted. A comment or resolution alone is not an update. Report the returned state, +resolution, assignment and validity without reproducing secret values. Marking an +alert `revoked` does not revoke credentials. GitHub enforces permissions and delegated +dismissal policy; report API errors without bypass or fallback. + ## Empty and failure cases - **An empty list and a disabled feature look alike.** An empty result means no open diff --git a/pkg/skills/catalog/skills/security-alert-triage/references/alert-sources.md b/pkg/skills/catalog/skills/security-alert-triage/references/alert-sources.md index ef4a3df36f..35f31b448f 100644 --- a/pkg/skills/catalog/skills/security-alert-triage/references/alert-sources.md +++ b/pkg/skills/catalog/skills/security-alert-triage/references/alert-sources.md @@ -37,7 +37,8 @@ Keep them apart when reporting. ## Secret scanning -- **Tools** — `list_secret_scanning_alerts`, `get_secret_scanning_alert`. +- **Tools** — `list_secret_scanning_alerts`, `get_secret_scanning_alert`, + `update_secret_scanning_alert` (when enabled and not read-only). - **What it finds** — credentials committed to the repository. - **Identity** — alert number, plus `secret_type`. - **Severity** — none. Treat every open alert as urgent until a person confirms the @@ -45,8 +46,10 @@ Keep them apart when reporting. - **The decisive fields** — `secret_type` says what to revoke and where; the alert's own state and resolution say whether anyone has already acted. - **Closed means** — `resolution` is one of `revoked`, `false_positive`, `wont_fix`, - `used_in_tests`, `pattern_edited`, `pattern_deleted`. Only `revoked` means the - credential can no longer be used. + `used_in_tests`, `pattern_edited`, `pattern_deleted`. The update tool accepts only + the first four reasons. `revoked` records a disposition, not proof of revocation; + credential revocation happens outside the alert update. A validity override also + does not validate or revoke the credential. ## Advisories diff --git a/pkg/skills/catalog/tools.go b/pkg/skills/catalog/tools.go index f6dc78951e..abe173d4b6 100644 --- a/pkg/skills/catalog/tools.go +++ b/pkg/skills/catalog/tools.go @@ -73,7 +73,7 @@ var requirements = map[string]toolRequirements{ }, "security-alert-triage": { required: [][]string{{"list_code_scanning_alerts", "list_dependabot_alerts", "list_secret_scanning_alerts", "list_repository_security_advisories", "list_org_repository_security_advisories"}}, - optional: []string{"get_code_scanning_alert", "update_code_scanning_alert", "get_dependabot_alert", "update_dependabot_alert", "get_secret_scanning_alert", "list_global_security_advisories", "get_global_security_advisory", "get_file_contents", "search_code"}, + optional: []string{"get_code_scanning_alert", "update_code_scanning_alert", "get_dependabot_alert", "update_dependabot_alert", "get_secret_scanning_alert", "update_secret_scanning_alert", "list_global_security_advisories", "get_global_security_advisory", "get_file_contents", "search_code"}, }, "workflow-failure-triage": { required: [][]string{{"actions_list"}, {"actions_get"}, {"get_job_logs"}}, From 3050fe99296ce2ec031a3ec43ae5d1dd3368143d Mon Sep 17 00:00:00 2001 From: Belal Taher Date: Wed, 18 Nov 2026 14:59:41 -0500 Subject: [PATCH 2/3] Inherit API defaults and clarify uncertain secret alert updates Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- pkg/github/update_secret_scanning_alert.go | 9 +- .../update_secret_scanning_alert_test.go | 98 ++++++++++++++++--- .../skills/security-alert-triage/SKILL.md | 3 + 3 files changed, 94 insertions(+), 16 deletions(-) diff --git a/pkg/github/update_secret_scanning_alert.go b/pkg/github/update_secret_scanning_alert.go index f368d731c2..9d3239b3a5 100644 --- a/pkg/github/update_secret_scanning_alert.go +++ b/pkg/github/update_secret_scanning_alert.go @@ -19,7 +19,6 @@ import ( "github.com/github/github-mcp-server/v2/pkg/scopes" "github.com/github/github-mcp-server/v2/pkg/translations" "github.com/github/github-mcp-server/v2/pkg/utils" - "github.com/google/go-github/v92/github" "github.com/google/jsonschema-go/jsonschema" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -99,7 +98,7 @@ func UpdateSecretScanningAlert(t translations.TranslationHelperFunc) inventory.S return utils.NewToolResultErrorFromErr("failed to get GitHub client", err), nil, err } path := fmt.Sprintf("repos/%s/%s/secret-scanning/alerts/%d", url.PathEscape(args.Owner), url.PathEscape(args.Repo), args.AlertNumber) - request, err := client.NewRequest(ctx, http.MethodPatch, path, args.SecretScanningAlertPatch, github.WithVersion("2026-03-10")) + request, err := client.NewRequest(ctx, http.MethodPatch, path, args.SecretScanningAlertPatch) if err != nil { return utils.NewToolResultErrorFromErr("failed to create secret scanning alert update request", err), nil, err } @@ -114,11 +113,15 @@ func UpdateSecretScanningAlert(t translations.TranslationHelperFunc) inventory.S if resp != nil && resp.Body != nil { defer func() { _ = resp.Body.Close() }() } + const uncertainOutcome = "The secret scanning alert update may already have been applied; verify the alert with get_secret_scanning_alert before retrying" if err != nil { + if resp != nil && resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusMultipleChoices { + return utils.NewToolResultErrorFromErr(uncertainOutcome, err), nil, nil + } return ghErrors.NewGitHubAPIErrorResponse(ctx, "failed to update secret scanning alert", resp, err), nil, nil } if resp.StatusCode != http.StatusOK || alert.Number != args.AlertNumber || !slices.Contains([]string{"open", "resolved"}, alert.State) { - return utils.NewToolResultError("invalid secret scanning alert update response"), nil, nil + return utils.NewToolResultError("unexpected secret scanning alert update response. " + uncertainOutcome + "."), nil, nil } output := SecretScanningAlertUpdateOutput{ Number: strconv.FormatInt(alert.Number, 10), State: alert.State, diff --git a/pkg/github/update_secret_scanning_alert_test.go b/pkg/github/update_secret_scanning_alert_test.go index cc22d043b6..5306328719 100644 --- a/pkg/github/update_secret_scanning_alert_test.go +++ b/pkg/github/update_secret_scanning_alert_test.go @@ -15,6 +15,7 @@ import ( "github.com/github/github-mcp-server/v2/pkg/inventory" "github.com/github/github-mcp-server/v2/pkg/scopes" "github.com/github/github-mcp-server/v2/pkg/translations" + "github.com/google/go-github/v92/github" "github.com/modelcontextprotocol/go-sdk/mcp" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -64,7 +65,7 @@ func TestUpdateSecretScanningAlert(t *testing.T) { assert.Equal(t, "PATCH /repos/Octo/Widgets.name/secret-scanning/alerts/42", r.Method+" "+r.URL.Path) assert.Empty(t, r.URL.RawQuery) assert.Equal(t, "Bearer test-token", r.Header.Get("Authorization")) - assert.Equal(t, "2026-03-10", r.Header.Get("X-GitHub-Api-Version")) + assert.Equal(t, "2022-11-28", r.Header.Get("X-GitHub-Api-Version")) body, err := io.ReadAll(r.Body) require.NoError(t, err) assert.JSONEq(t, tc.patch, string(body), "preserve omitted and null PATCH fields") @@ -112,6 +113,62 @@ func TestUpdateSecretScanningAlert(t *testing.T) { } } +func TestUpdateSecretScanningAlertConfiguredClient(t *testing.T) { + t.Parallel() + for _, protocol := range []string{"2025-11-25", inventory.ProtocolVersionMultiRoundTrip} { + for _, tc := range []struct { + name, baseURL, uploadURL, host, prefix string + }{ + {"cloud", "", "", "api.github.com", ""}, + {"enterprise", "https://ghe.example/api/v3/", "https://ghe.example/api/uploads/", "ghe.example", "/api/v3"}, + } { + t.Run(protocol+"/"+tc.name, func(t *testing.T) { + t.Parallel() + calls := 0 + httpClient := MockHTTPClientWithHandler(func(w http.ResponseWriter, r *http.Request) { + calls++ + assert.Equal(t, "https", r.URL.Scheme) + assert.Equal(t, tc.host, r.URL.Host) + assert.Equal(t, tc.prefix+"/repos/octo/widgets/secret-scanning/alerts/42", r.URL.Path) + assert.Equal(t, http.MethodPatch, r.Method) + assert.Equal(t, "Bearer configured-token", r.Header.Get("Authorization")) + assert.Equal(t, "configured-agent", r.Header.Get("User-Agent")) + assert.Equal(t, "2022-11-28", r.Header.Get("X-GitHub-Api-Version")) + assert.Equal(t, "application/vnd.github.v3+json", r.Header.Get("Accept")) + _, _ = io.WriteString(w, `{"number":42,"state":"open"}`) + }) + httpClient.Transport = &transport.BearerAuthTransport{ + Transport: httpClient.Transport, Token: "configured-token", AllowedHosts: []string{tc.host}, + } + options := []github.ClientOptionsFunc{github.WithHTTPClient(httpClient), github.WithUserAgent("configured-agent")} + if tc.baseURL != "" { + options = append(options, github.WithEnterpriseURLs(tc.baseURL, tc.uploadURL)) + } + client, err := github.NewClient(options...) + require.NoError(t, err) + baseline, err := client.NewRequest(t.Context(), http.MethodGet, "repos/octo/widgets", nil) + require.NoError(t, err) + deps := &BaseDeps{Client: client} + server := mcp.NewServer(&mcp.Implementation{Name: "configured-client-test", Version: "1"}, nil) + server.AddReceivingMiddleware(InjectDepsMiddleware(deps)) + tool := UpdateSecretScanningAlert(translations.NullTranslationHelper) + tool.RegisterFunc(server, deps) + session := connectCommentVisibilityClient(t, server, protocol) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: tool.Tool.Name, Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "assignee": nil, + }}) + require.NoError(t, err) + require.False(t, result.IsError, "%+v", result.Content) + assert.Equal(t, 1, calls) + after, err := client.NewRequest(t.Context(), http.MethodGet, "repos/octo/widgets", nil) + require.NoError(t, err) + assert.Equal(t, baseline.URL, after.URL) + assert.Equal(t, baseline.Header, after.Header) + }) + } + } +} + func TestUpdateSecretScanningAlertRejectsInvalidInput(t *testing.T) { t.Parallel() base := map[string]any{"owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "open"} @@ -196,19 +253,22 @@ func TestUpdateSecretScanningAlertErrors(t *testing.T) { require.NoError(t, err) require.True(t, result.IsError) assert.Contains(t, getTextResult(t, result).Text, "delegated dismissal or update denied") + assert.NotContains(t, getTextResult(t, result).Text, "may already have been applied") assert.Equal(t, 1, calls, "no fallback writes") assert.Nil(t, result.StructuredContent) assert.NotContains(t, result.Meta, "ifc") }) } for _, response := range []string{ - `{`, `null`, `{}`, `{"number":42}`, `{"number":42,"state":null}`, + ``, `{`, `null`, `{}`, `{"number":42}`, `{"number":42,"state":null}`, `{"number":42,"state":"invalid"}`, `{"number":42,"state":true}`, `{"number":42,"state":"open","assigned_to":5}`, `{"number":43,"state":"open"}`, } { t.Run(protocol+"/"+response, func(t *testing.T) { t.Parallel() + calls := 0 session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + calls++ _, _ = io.WriteString(w, response) }, protocol, true) result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ @@ -216,21 +276,33 @@ func TestUpdateSecretScanningAlertErrors(t *testing.T) { }}) require.NoError(t, err) require.True(t, result.IsError) + assert.Contains(t, getTextResult(t, result).Text, "may already have been applied") + assert.Contains(t, getTextResult(t, result).Text, "verify the alert with get_secret_scanning_alert before retrying") + assert.Equal(t, 1, calls, "never retry an uncertain write") + assert.Nil(t, result.StructuredContent) + assert.NotContains(t, result.Meta, "ifc") + }) + } + for _, status := range []int{http.StatusAccepted, http.StatusNoContent} { + t.Run(protocol+"/"+fmt.Sprint(status), func(t *testing.T) { + t.Parallel() + calls := 0 + session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { + calls++ + w.WriteHeader(status) + }, protocol, true) + result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ + "owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "open", + }}) + require.NoError(t, err) + require.True(t, result.IsError) + assert.Contains(t, getTextResult(t, result).Text, "may already have been applied") + assert.Contains(t, getTextResult(t, result).Text, "verify the alert with get_secret_scanning_alert before retrying") + assert.Equal(t, 1, calls, "never retry an uncertain write") assert.Nil(t, result.StructuredContent) assert.NotContains(t, result.Meta, "ifc") }) } - t.Run(protocol+"/no content", func(t *testing.T) { - t.Parallel() - session, _ := secretScanningUpdateSession(t, func(w http.ResponseWriter, _ *http.Request) { - w.WriteHeader(http.StatusNoContent) - }, protocol, false) - result, err := session.CallTool(t.Context(), &mcp.CallToolParams{Name: "update_secret_scanning_alert", Arguments: map[string]any{ - "owner": "octo", "repo": "widgets", "alertNumber": 42, "state": "open", - }}) - require.NoError(t, err) - require.True(t, result.IsError) - }) } } diff --git a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md index bd5da2b104..b0d382e9a2 100644 --- a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md +++ b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md @@ -131,6 +131,9 @@ deleted. A comment or resolution alone is not an update. Report the returned sta resolution, assignment and validity without reproducing secret values. Marking an alert `revoked` does not revoke credentials. GitHub enforces permissions and delegated dismissal policy; report API errors without bypass or fallback. +If an update reports that it may already have been applied, inspect the alert with +`get_secret_scanning_alert` and `hide_secret: true` before retrying; an unreadable +success response does not prove that the write failed. ## Empty and failure cases From 1f9f2862b170b653ddedaa8d3346aa35cf534f41 Mon Sep 17 00:00:00 2001 From: Belal Taher Date: Wed, 18 Nov 2026 15:07:22 -0500 Subject: [PATCH 3/3] Clarify custom-pattern-only validity overrides Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- README.md | 2 +- pkg/github/__toolsnaps__/update_secret_scanning_alert.snap | 4 ++-- pkg/github/update_secret_scanning_alert.go | 5 +++-- pkg/skills/catalog/skills/security-alert-triage/SKILL.md | 5 ++++- 4 files changed, 10 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index b2c9a2db80..166dbe0c9c 100644 --- a/README.md +++ b/README.md @@ -1623,7 +1623,7 @@ For negotiated supported protocol versions `2026-07-28` or newer, the consolidat - `resolution`: Reason for resolving. Non-null when state is resolved. (string | null, optional) - `resolution_comment`: Optional comment when closing or reopening; cannot later be updated or deleted. (string | null, optional) - `state`: Reopen or resolve the alert. (string, optional) - - `validity`: Manual validity override; null clears the override. (string | null, optional) + - `validity`: Manual validity override for custom-pattern alerts only; null clears the override. GitHub-supported patterns retain validator-managed validity. (string | null, optional)
diff --git a/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap b/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap index e430ff2488..74398586c9 100644 --- a/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap +++ b/pkg/github/__toolsnaps__/update_secret_scanning_alert.snap @@ -6,7 +6,7 @@ "readOnlyHint": false, "title": "Update secret scanning alert" }, - "description": "Update a secret scanning alert's state, assignee, or validity override. Provide at least one of state, assignee, or validity. Resolving requires a non-null resolution. Omitted fields are unchanged; null unassigns the assignee or clears the validity override. Resolution comments accompany closing or reopening and cannot later be edited or deleted. Resolution revoked does not revoke credentials; validity is a manual override, not a validation request. Requires repository secret scanning write access. Delegated dismissal may require Secret scanning alert dismissal requests write permission and an authorized reviewer; API policy failures are returned without bypass.", + "description": "Update a secret scanning alert's state, assignee, or validity override. Provide at least one of state, assignee, or validity. Resolving requires a non-null resolution. Omitted fields are unchanged; null unassigns the assignee or clears the validity override. Resolution comments accompany closing or reopening and cannot later be edited or deleted. Resolution revoked does not revoke credentials; validity is a manual override for custom-pattern alerts only, not a validation request. GitHub-supported patterns retain validator-managed validity and cannot be overridden through this endpoint. Requires repository secret scanning write access. Delegated dismissal may require Secret scanning alert dismissal requests write permission and an authorized reviewer; API policy failures are returned without bypass.", "inputSchema": { "additionalProperties": false, "properties": { @@ -62,7 +62,7 @@ "type": "string" }, "validity": { - "description": "Manual validity override; null clears the override.", + "description": "Manual validity override for custom-pattern alerts only; null clears the override. GitHub-supported patterns retain validator-managed validity.", "enum": [ "active", "inactive", diff --git a/pkg/github/update_secret_scanning_alert.go b/pkg/github/update_secret_scanning_alert.go index 9d3239b3a5..58377e7ef7 100644 --- a/pkg/github/update_secret_scanning_alert.go +++ b/pkg/github/update_secret_scanning_alert.go @@ -61,7 +61,8 @@ func UpdateSecretScanningAlert(t translations.TranslationHelperFunc) inventory.S "Provide at least one of state, assignee, or validity. Resolving requires a non-null resolution. "+ "Omitted fields are unchanged; null unassigns the assignee or clears the validity override. "+ "Resolution comments accompany closing or reopening and cannot later be edited or deleted. "+ - "Resolution revoked does not revoke credentials; validity is a manual override, not a validation request. "+ + "Resolution revoked does not revoke credentials; validity is a manual override for custom-pattern alerts only, not a validation request. "+ + "GitHub-supported patterns retain validator-managed validity and cannot be overridden through this endpoint. "+ "Requires repository secret scanning write access. Delegated dismissal may require Secret scanning alert dismissal requests write permission and an authorized reviewer; API policy failures are returned without bypass."), Annotations: &mcp.ToolAnnotations{ Title: t("TOOL_UPDATE_SECRET_SCANNING_ALERT_USER_TITLE", "Update secret scanning alert"), @@ -80,7 +81,7 @@ func UpdateSecretScanningAlert(t translations.TranslationHelperFunc) inventory.S "resolution": {Types: []string{"string", "null"}, Enum: []any{"false_positive", "wont_fix", "revoked", "used_in_tests", nil}, Description: "Reason for resolving. Non-null when state is resolved."}, "resolution_comment": {Types: []string{"string", "null"}, Description: "Optional comment when closing or reopening; cannot later be updated or deleted."}, "assignee": {Types: []string{"string", "null"}, Description: "Username with repository write access; null unassigns."}, - "validity": {Types: []string{"string", "null"}, Enum: []any{"active", "inactive", nil}, Description: "Manual validity override; null clears the override."}, + "validity": {Types: []string{"string", "null"}, Enum: []any{"active", "inactive", nil}, Description: "Manual validity override for custom-pattern alerts only; null clears the override. GitHub-supported patterns retain validator-managed validity."}, }, Required: []string{"owner", "repo", "alertNumber"}, }, diff --git a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md index b0d382e9a2..6485ffb76c 100644 --- a/pkg/skills/catalog/skills/security-alert-triage/SKILL.md +++ b/pkg/skills/catalog/skills/security-alert-triage/SKILL.md @@ -125,7 +125,10 @@ a non-null `resolution`: `false_positive`, `wont_fix`, `revoked`, or `used_in_te Omitted fields stay unchanged. `resolution`, `resolution_comment`, `assignee`, and `validity` accept null; null unassigns the assignee or clears the validity override. A non-null assignee is a username with repository write access. Validity accepts -`active` or `inactive`; it is a manual override, not a request to validate a secret. +`active` or `inactive` for custom-pattern alerts only; it is a manual override, not +a request to validate a secret. GitHub-supported patterns retain validator-managed +validity and cannot be overridden through this endpoint. GitHub enforces this +restriction; report rejected updates rather than bypassing it. Resolution comments accompany closing or reopening and cannot later be edited or deleted. A comment or resolution alone is not an update. Report the returned state, resolution, assignment and validity without reproducing secret values. Marking an