Merge branch 'main' into improve/license-automation

Author: SamMorrowDrums

.github/workflows/docker-publish.yml

@@ -54,7 +54,7 @@ jobs:
       # multi-platform images and export cache
       # https://github.com/docker/setup-buildx-action
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       # Login against a Docker registry except on PR
       # https://github.com/docker/login-action

README.md

@@ -393,7 +393,7 @@ When using Docker, you can pass the toolsets as environment variables:
 ```bash
 docker run -i --rm \
   -e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> \
-  -e GITHUB_TOOLSETS="repos,issues,pull_requests,actions,code_security,experiments" \
+  -e GITHUB_TOOLSETS="repos,issues,pull_requests,actions,code_security" \
   ghcr.io/github/github-mcp-server
 ```
 
@@ -490,6 +490,40 @@ The following sets of tools are available:
 
 <summary><picture><source media="(prefers-color-scheme: dark)" srcset="pkg/octicons/icons/workflow-dark.png"><source media="(prefers-color-scheme: light)" srcset="pkg/octicons/icons/workflow-light.png"><img src="pkg/octicons/icons/workflow-light.png" width="20" height="20" alt="workflow"></picture> Actions</summary>
 
+- **actions_get** - Get details of GitHub Actions resources (workflows, workflow runs, jobs, and artifacts)
+  - `method`: The method to execute (string, required)
+  - `owner`: Repository owner (string, required)
+  - `repo`: Repository name (string, required)
+  - `resource_id`: The unique identifier of the resource. This will vary based on the "method" provided, so ensure you provide the correct ID:
+    - Provide a workflow ID or workflow file name (e.g. ci.yaml) for 'get_workflow' method.
+    - Provide a workflow run ID for 'get_workflow_run', 'get_workflow_run_usage', and 'get_workflow_run_logs_url' methods.
+    - Provide an artifact ID for 'download_workflow_run_artifact' method.
+    - Provide a job ID for 'get_workflow_job' method.
+     (string, required)
+
+- **actions_list** - List GitHub Actions workflows in a repository
+  - `method`: The action to perform (string, required)
+  - `owner`: Repository owner (string, required)
+  - `page`: Page number for pagination (default: 1) (number, optional)
+  - `per_page`: Results per page for pagination (default: 30, max: 100) (number, optional)
+  - `repo`: Repository name (string, required)
+  - `resource_id`: The unique identifier of the resource. This will vary based on the "method" provided, so ensure you provide the correct ID:
+    - Do not provide any resource ID for 'list_workflows' method.
+    - Provide a workflow ID or workflow file name (e.g. ci.yaml) for 'list_workflow_runs' method.
+    - Provide a workflow run ID for 'list_workflow_jobs' and 'list_workflow_run_artifacts' methods.
+     (string, optional)
+  - `workflow_jobs_filter`: Filters for workflow jobs. **ONLY** used when method is 'list_workflow_jobs' (object, optional)
+  - `workflow_runs_filter`: Filters for workflow runs. **ONLY** used when method is 'list_workflow_runs' (object, optional)
+
+- **actions_run_trigger** - Trigger GitHub Actions workflow actions
+  - `inputs`: Inputs the workflow accepts. Only used for 'run_workflow' method. (object, optional)
+  - `method`: The method to execute (string, required)
+  - `owner`: Repository owner (string, required)
+  - `ref`: The git reference for the workflow. The reference can be a branch or tag name. Required for 'run_workflow' method. (string, optional)
+  - `repo`: Repository name (string, required)
+  - `run_id`: The ID of the workflow run. Required for all methods except 'run_workflow'. (number, optional)
+  - `workflow_id`: The workflow ID (numeric) or workflow file name (e.g., main.yml, ci.yaml). Required for 'run_workflow' method. (string, optional)
+
 - **cancel_workflow_run** - Cancel workflow run
   - `owner`: Repository owner (string, required)
   - `repo`: Repository name (string, required)
@@ -514,6 +548,15 @@ The following sets of tools are available:
   - `run_id`: Workflow run ID (required when using failed_only) (number, optional)
   - `tail_lines`: Number of lines to return from the end of the log (number, optional)
 
+- **get_job_logs** - Get GitHub Actions workflow job logs
+  - `failed_only`: When true, gets logs for all failed jobs in the workflow run specified by run_id. Requires run_id to be provided. (boolean, optional)
+  - `job_id`: The unique identifier of the workflow job. Required when getting logs for a single job. (number, optional)
+  - `owner`: Repository owner (string, required)
+  - `repo`: Repository name (string, required)
+  - `return_content`: Returns actual log content instead of URLs (boolean, optional)
+  - `run_id`: The unique identifier of the workflow run. Required when failed_only is true to get logs for all failed jobs in the run. (number, optional)
+  - `tail_lines`: Number of lines to return from the end of the log (number, optional)
+
 - **get_workflow_run** - Get workflow run
   - `owner`: Repository owner (string, required)
   - `repo`: Repository name (string, required)

cmd/github-mcp-server/main.go

@@ -54,14 +54,18 @@ var (
 
 			// Parse tools (similar to toolsets)
 			var enabledTools []string
-			if err := viper.UnmarshalKey("tools", &enabledTools); err != nil {
-				return fmt.Errorf("failed to unmarshal tools: %w", err)
+			if viper.IsSet("tools") {
+				if err := viper.UnmarshalKey("tools", &enabledTools); err != nil {
+					return fmt.Errorf("failed to unmarshal tools: %w", err)
+				}
 			}
 
 			// Parse enabled features (similar to toolsets)
 			var enabledFeatures []string
-			if err := viper.UnmarshalKey("features", &enabledFeatures); err != nil {
-				return fmt.Errorf("failed to unmarshal features: %w", err)
+			if viper.IsSet("features") {
+				if err := viper.UnmarshalKey("features", &enabledFeatures); err != nil {
+					return fmt.Errorf("failed to unmarshal features: %w", err)
+				}
 			}
 
 			ttl := viper.GetDuration("repo-access-cache-ttl")

docs/tool-renaming.md

@@ -46,5 +46,20 @@ Will get `issue_read` and `get_file_contents` tools registered, with no errors.
 <!-- START AUTOMATED ALIASES -->
 | Old Name | New Name |
 |----------|----------|
-| *(none currently)* | |
+| `cancel_workflow_run` | `actions_run_trigger` |
+| `delete_workflow_run_logs` | `actions_run_trigger` |
+| `download_workflow_run_artifact` | `actions_get` |
+| `get_workflow` | `actions_get` |
+| `get_workflow_job` | `actions_get` |
+| `get_workflow_job_logs` | `actions_get` |
+| `get_workflow_run` | `actions_get` |
+| `get_workflow_run_logs` | `actions_get` |
+| `get_workflow_run_usage` | `actions_get` |
+| `list_workflow_jobs` | `actions_list` |
+| `list_workflow_run_artifacts` | `actions_list` |
+| `list_workflow_runs` | `actions_list` |
+| `list_workflows` | `actions_list` |
+| `rerun_failed_jobs` | `actions_run_trigger` |
+| `rerun_workflow_run` | `actions_run_trigger` |
+| `run_workflow` | `actions_run_trigger` |
 <!-- END AUTOMATED ALIASES -->

internal/ghmcp/server.go

@@ -203,6 +203,13 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 		cfg.ContentWindowSize,
 	)
 
+	// Inject dependencies into context for all tool handlers
+	ghServer.AddReceivingMiddleware(func(next mcp.MethodHandler) mcp.MethodHandler {
+		return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
+			return next(github.ContextWithDeps(ctx, deps), method, req)
+		}
+	})
+
 	// Build and register the tool/resource/prompt inventory
 	inventory := github.NewInventory(cfg.Translator).
 		WithDeprecatedAliases(github.DeprecatedToolAliases).

internal/ghmcp/server_test.go

@@ -0,0 +1,112 @@
+package ghmcp
+
+import (
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestNewMCPServer_CreatesSuccessfully verifies that the server can be created
+// with the deps injection middleware properly configured.
+func TestNewMCPServer_CreatesSuccessfully(t *testing.T) {
+	t.Parallel()
+
+	// Create a minimal server configuration
+	cfg := MCPServerConfig{
+		Version:           "test",
+		Host:              "", // defaults to github.com
+		Token:             "test-token",
+		EnabledToolsets:   []string{"context"},
+		ReadOnly:          false,
+		Translator:        translations.NullTranslationHelper,
+		ContentWindowSize: 5000,
+		LockdownMode:      false,
+	}
+
+	// Create the server
+	server, err := NewMCPServer(cfg)
+	require.NoError(t, err, "expected server creation to succeed")
+	require.NotNil(t, server, "expected server to be non-nil")
+
+	// The fact that the server was created successfully indicates that:
+	// 1. The deps injection middleware is properly added
+	// 2. Tools can be registered without panicking
+	//
+	// If the middleware wasn't properly added, tool calls would panic with
+	// "ToolDependencies not found in context" when executed.
+	//
+	// The actual middleware functionality and tool execution with ContextWithDeps
+	// is already tested in pkg/github/*_test.go.
+}
+
+// TestResolveEnabledToolsets verifies the toolset resolution logic.
+func TestResolveEnabledToolsets(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		cfg            MCPServerConfig
+		expectedResult []string
+	}{
+		{
+			name: "nil toolsets without dynamic mode and no tools - use defaults",
+			cfg: MCPServerConfig{
+				EnabledToolsets: nil,
+				DynamicToolsets: false,
+				EnabledTools:    nil,
+			},
+			expectedResult: nil, // nil means "use defaults"
+		},
+		{
+			name: "nil toolsets with dynamic mode - start empty",
+			cfg: MCPServerConfig{
+				EnabledToolsets: nil,
+				DynamicToolsets: true,
+				EnabledTools:    nil,
+			},
+			expectedResult: []string{}, // empty slice means no toolsets
+		},
+		{
+			name: "explicit toolsets",
+			cfg: MCPServerConfig{
+				EnabledToolsets: []string{"repos", "issues"},
+				DynamicToolsets: false,
+			},
+			expectedResult: []string{"repos", "issues"},
+		},
+		{
+			name: "empty toolsets - disable all",
+			cfg: MCPServerConfig{
+				EnabledToolsets: []string{},
+				DynamicToolsets: false,
+			},
+			expectedResult: []string{}, // empty slice means no toolsets
+		},
+		{
+			name: "specific tools without toolsets - no default toolsets",
+			cfg: MCPServerConfig{
+				EnabledToolsets: nil,
+				DynamicToolsets: false,
+				EnabledTools:    []string{"get_me"},
+			},
+			expectedResult: []string{}, // empty slice when tools specified but no toolsets
+		},
+		{
+			name: "dynamic mode with explicit toolsets removes all and default",
+			cfg: MCPServerConfig{
+				EnabledToolsets: []string{"all", "repos"},
+				DynamicToolsets: true,
+			},
+			expectedResult: []string{"repos"}, // "all" is removed in dynamic mode
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := resolveEnabledToolsets(tc.cfg)
+			assert.Equal(t, tc.expectedResult, result)
+		})
+	}
+}

pkg/buffer/buffer.go

@@ -26,6 +26,10 @@ import (
 // The function uses a ring buffer to efficiently store only the last maxJobLogLines lines.
 // If the response contains more lines than maxJobLogLines, only the most recent lines are kept.
 func ProcessResponseAsRingBufferToEnd(httpResp *http.Response, maxJobLogLines int) (string, int, *http.Response, error) {
+	if maxJobLogLines > 100000 {
+		maxJobLogLines = 100000
+	}
+
 	lines := make([]string, maxJobLogLines)
 	validLines := make([]bool, maxJobLogLines)
 	totalLines := 0

pkg/errors/error.go

@@ -3,6 +3,7 @@ package errors
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	"github.com/github/github-mcp-server/pkg/utils"
 	"github.com/google/go-github/v79/github"
@@ -44,10 +45,29 @@ func (e *GitHubGraphQLError) Error() string {
 	return fmt.Errorf("%s: %w", e.Message, e.Err).Error()
 }
 
+type GitHubRawAPIError struct {
+	Message  string         `json:"message"`
+	Response *http.Response `json:"-"`
+	Err      error          `json:"-"`
+}
+
+func newGitHubRawAPIError(message string, resp *http.Response, err error) *GitHubRawAPIError {
+	return &GitHubRawAPIError{
+		Message:  message,
+		Response: resp,
+		Err:      err,
+	}
+}
+
+func (e *GitHubRawAPIError) Error() string {
+	return fmt.Errorf("%s: %w", e.Message, e.Err).Error()
+}
+
 type GitHubErrorKey struct{}
 type GitHubCtxErrors struct {
 	api     []*GitHubAPIError
 	graphQL []*GitHubGraphQLError
+	raw     []*GitHubRawAPIError
 }
 
 // ContextWithGitHubErrors updates or creates a context with a pointer to GitHub error information (to be used by middleware).
@@ -59,6 +79,7 @@ func ContextWithGitHubErrors(ctx context.Context) context.Context {
 		// If the context already has GitHubCtxErrors, we just empty the slices to start fresh
 		val.api = []*GitHubAPIError{}
 		val.graphQL = []*GitHubGraphQLError{}
+		val.raw = []*GitHubRawAPIError{}
 	} else {
 		// If not, we create a new GitHubCtxErrors and set it in the context
 		ctx = context.WithValue(ctx, GitHubErrorKey{}, &GitHubCtxErrors{})
@@ -83,6 +104,14 @@ func GetGitHubGraphQLErrors(ctx context.Context) ([]*GitHubGraphQLError, error)
 	return nil, fmt.Errorf("context does not contain GitHubCtxErrors")
 }
 
+// GetGitHubRawAPIErrors retrieves the slice of GitHubRawAPIErrors from the context.
+func GetGitHubRawAPIErrors(ctx context.Context) ([]*GitHubRawAPIError, error) {
+	if val, ok := ctx.Value(GitHubErrorKey{}).(*GitHubCtxErrors); ok {
+		return val.raw, nil // return the slice of raw API errors from the context
+	}
+	return nil, fmt.Errorf("context does not contain GitHubCtxErrors")
+}
+
 func NewGitHubAPIErrorToCtx(ctx context.Context, message string, resp *github.Response, err error) (context.Context, error) {
 	apiErr := newGitHubAPIError(message, resp, err)
 	if ctx != nil {
@@ -107,6 +136,15 @@ func addGitHubGraphQLErrorToContext(ctx context.Context, err *GitHubGraphQLError
 	return nil, fmt.Errorf("context does not contain GitHubCtxErrors")
 }
 
+func addRawAPIErrorToContext(ctx context.Context, err *GitHubRawAPIError) (context.Context, error) {
+	if val, ok := ctx.Value(GitHubErrorKey{}).(*GitHubCtxErrors); ok {
+		val.raw = append(val.raw, err)
+		return ctx, nil
+	}
+
+	return nil, fmt.Errorf("context does not contain GitHubCtxErrors")
+}
+
 // NewGitHubAPIErrorResponse returns an mcp.NewToolResultError and retains the error in the context for access via middleware
 func NewGitHubAPIErrorResponse(ctx context.Context, message string, resp *github.Response, err error) *mcp.CallToolResult {
 	apiErr := newGitHubAPIError(message, resp, err)
@@ -125,6 +163,15 @@ func NewGitHubGraphQLErrorResponse(ctx context.Context, message string, err erro
 	return utils.NewToolResultErrorFromErr(message, err)
 }
 
+// NewGitHubRawAPIErrorResponse returns an mcp.NewToolResultError and retains the error in the context for access via middleware
+func NewGitHubRawAPIErrorResponse(ctx context.Context, message string, resp *http.Response, err error) *mcp.CallToolResult {
+	rawErr := newGitHubRawAPIError(message, resp, err)
+	if ctx != nil {
+		_, _ = addRawAPIErrorToContext(ctx, rawErr) // Explicitly ignore error for graceful handling
+	}
+	return utils.NewToolResultErrorFromErr(message, err)
+}
+
 // NewGitHubAPIStatusErrorResponse handles cases where the API call succeeds (err == nil)
 // but returns an unexpected HTTP status code. It creates a synthetic error from the
 // status code and response body, then records it in context for observability tracking.