feat: unify workflow execution in GitHub Actions tools

- Refactored the RunWorkflow tool to accept both numeric workflow IDs and filenames, enhancing flexibility for users.
- Updated the corresponding tests to reflect changes in parameter handling and added assertions for workflow type in responses.
- Removed the separate RunWorkflowByFileName tool to streamline functionality and improve code maintainability.

Author: gabornyergesX

pkg/github/actions.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strconv"
 	"strings"
 
 	"github.com/github/github-mcp-server/pkg/translations"
@@ -236,10 +237,10 @@ func ListWorkflowRuns(getClient GetClientFn, t translations.TranslationHelperFun
 		}
 }
 
-// RunWorkflow creates a tool to run an Actions workflow by workflow ID
+// RunWorkflow creates a tool to run an Actions workflow
 func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("run_workflow",
-			mcp.WithDescription(t("TOOL_RUN_WORKFLOW_DESCRIPTION", "Run an Actions workflow by workflow ID")),
+			mcp.WithDescription(t("TOOL_RUN_WORKFLOW_DESCRIPTION", "Run an Actions workflow by workflow ID or filename")),
 			mcp.WithToolAnnotation(mcp.ToolAnnotation{
 				Title:        t("TOOL_RUN_WORKFLOW_USER_TITLE", "Run workflow"),
 				ReadOnlyHint: ToBoolPtr(false),
@@ -252,9 +253,9 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 				mcp.Required(),
 				mcp.Description(DescriptionRepositoryName),
 			),
-			mcp.WithNumber("workflow_id",
+			mcp.WithString("workflow_id",
 				mcp.Required(),
-				mcp.Description("The workflow ID (numeric identifier)"),
+				mcp.Description("The workflow ID (numeric) or workflow file name (e.g., main.yml, ci.yaml)"),
 			),
 			mcp.WithString("ref",
 				mcp.Required(),
@@ -273,11 +274,10 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
-			workflowIDInt, err := RequiredInt(request, "workflow_id")
+			workflowID, err := RequiredParam[string](request, "workflow_id")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
-			workflowID := int64(workflowIDInt)
 			ref, err := RequiredParam[string](request, "ref")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
@@ -301,105 +301,26 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 				Inputs: inputs,
 			}
 
-			// Convert workflow ID to string format for the API call
-			workflowIDStr := fmt.Sprintf("%d", workflowID)
-			resp, err := client.Actions.CreateWorkflowDispatchEventByFileName(ctx, owner, repo, workflowIDStr, event)
-			if err != nil {
-				return nil, fmt.Errorf("failed to run workflow: %w", err)
-			}
-			defer func() { _ = resp.Body.Close() }()
-
-			result := map[string]any{
-				"message":     "Workflow run has been queued",
-				"workflow_id": workflowID,
-				"ref":         ref,
-				"inputs":      inputs,
-				"status":      resp.Status,
-				"status_code": resp.StatusCode,
-			}
-
-			r, err := json.Marshal(result)
-			if err != nil {
-				return nil, fmt.Errorf("failed to marshal response: %w", err)
-			}
-
-			return mcp.NewToolResultText(string(r)), nil
-		}
-}
-
-// RunWorkflowByFileName creates a tool to run an Actions workflow by filename
-func RunWorkflowByFileName(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
-	return mcp.NewTool("run_workflow_by_filename",
-			mcp.WithDescription(t("TOOL_RUN_WORKFLOW_BY_FILENAME_DESCRIPTION", "Run an Actions workflow by workflow filename")),
-			mcp.WithToolAnnotation(mcp.ToolAnnotation{
-				Title:        t("TOOL_RUN_WORKFLOW_BY_FILENAME_USER_TITLE", "Run workflow by filename"),
-				ReadOnlyHint: ToBoolPtr(false),
-			}),
-			mcp.WithString("owner",
-				mcp.Required(),
-				mcp.Description(DescriptionRepositoryOwner),
-			),
-			mcp.WithString("repo",
-				mcp.Required(),
-				mcp.Description(DescriptionRepositoryName),
-			),
-			mcp.WithString("workflow_file",
-				mcp.Required(),
-				mcp.Description("The workflow file name (e.g., main.yml, ci.yaml)"),
-			),
-			mcp.WithString("ref",
-				mcp.Required(),
-				mcp.Description("The git reference for the workflow. The reference can be a branch or tag name."),
-			),
-			mcp.WithObject("inputs",
-				mcp.Description("Inputs the workflow accepts"),
-			),
-		),
-		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-			owner, err := RequiredParam[string](request, "owner")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			repo, err := RequiredParam[string](request, "repo")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			workflowFile, err := RequiredParam[string](request, "workflow_file")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			ref, err := RequiredParam[string](request, "ref")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-
-			// Get optional inputs parameter
-			var inputs map[string]interface{}
-			if requestInputs, ok := request.GetArguments()["inputs"]; ok {
-				if inputsMap, ok := requestInputs.(map[string]interface{}); ok {
-					inputs = inputsMap
-				}
-			}
-
-			client, err := getClient(ctx)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
-			}
+			var resp *github.Response
+			var workflowType string
 
-			event := github.CreateWorkflowDispatchEventRequest{
-				Ref:    ref,
-				Inputs: inputs,
+			if workflowIDInt, parseErr := strconv.ParseInt(workflowID, 10, 64); parseErr == nil {
+				resp, err = client.Actions.CreateWorkflowDispatchEventByID(ctx, owner, repo, workflowIDInt, event)
+				workflowType = "workflow_id"
+			} else {
+				resp, err = client.Actions.CreateWorkflowDispatchEventByFileName(ctx, owner, repo, workflowID, event)
+				workflowType = "workflow_file"
 			}
 
-			resp, err := client.Actions.CreateWorkflowDispatchEventByFileName(ctx, owner, repo, workflowFile, event)
 			if err != nil {
 				return nil, fmt.Errorf("failed to run workflow: %w", err)
 			}
 			defer func() { _ = resp.Body.Close() }()
 
 			result := map[string]any{
 				"message":       "Workflow run has been queued",
-				"workflow_file": workflowFile,
+				"workflow_type": workflowType,
+				"workflow_id":   workflowID,
 				"ref":           ref,
 				"inputs":        inputs,
 				"status":        resp.Status,

pkg/github/actions_test.go

@@ -159,7 +159,7 @@ func Test_RunWorkflow(t *testing.T) {
 			requestArgs: map[string]any{
 				"owner":       "owner",
 				"repo":        "repo",
-				"workflow_id": float64(12345),
+				"workflow_id": "12345",
 				"ref":         "main",
 			},
 			expectError: false,
@@ -205,24 +205,13 @@ func Test_RunWorkflow(t *testing.T) {
 			err = json.Unmarshal([]byte(textContent.Text), &response)
 			require.NoError(t, err)
 			assert.Equal(t, "Workflow run has been queued", response["message"])
+			assert.Contains(t, response, "workflow_type")
 		})
 	}
 }
 
-func Test_RunWorkflowByFileName(t *testing.T) {
-	// Verify tool definition once
-	mockClient := github.NewClient(nil)
-	tool, _ := RunWorkflowByFileName(stubGetClientFn(mockClient), translations.NullTranslationHelper)
-
-	assert.Equal(t, "run_workflow_by_filename", tool.Name)
-	assert.NotEmpty(t, tool.Description)
-	assert.Contains(t, tool.InputSchema.Properties, "owner")
-	assert.Contains(t, tool.InputSchema.Properties, "repo")
-	assert.Contains(t, tool.InputSchema.Properties, "workflow_file")
-	assert.Contains(t, tool.InputSchema.Properties, "ref")
-	assert.Contains(t, tool.InputSchema.Properties, "inputs")
-	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo", "workflow_file", "ref"})
-
+func Test_RunWorkflow_WithFilename(t *testing.T) {
+	// Test the unified RunWorkflow function with filenames
 	tests := []struct {
 		name           string
 		mockedClient   *http.Client
@@ -241,31 +230,49 @@ func Test_RunWorkflowByFileName(t *testing.T) {
 				),
 			),
 			requestArgs: map[string]any{
-				"owner":         "owner",
-				"repo":          "repo",
-				"workflow_file": "ci.yml",
-				"ref":           "main",
+				"owner":       "owner",
+				"repo":        "repo",
+				"workflow_id": "ci.yml",
+				"ref":         "main",
 			},
 			expectError: false,
 		},
 		{
-			name:         "missing required parameter workflow_file",
+			name: "successful workflow run by numeric ID as string",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatchHandler(
+					mock.PostReposActionsWorkflowsDispatchesByOwnerByRepoByWorkflowId,
+					http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+						w.WriteHeader(http.StatusNoContent)
+					}),
+				),
+			),
+			requestArgs: map[string]any{
+				"owner":       "owner",
+				"repo":        "repo",
+				"workflow_id": "12345",
+				"ref":         "main",
+			},
+			expectError: false,
+		},
+		{
+			name:         "missing required parameter workflow_id",
 			mockedClient: mock.NewMockedHTTPClient(),
 			requestArgs: map[string]any{
 				"owner": "owner",
 				"repo":  "repo",
 				"ref":   "main",
 			},
 			expectError:    true,
-			expectedErrMsg: "missing required parameter: workflow_file",
+			expectedErrMsg: "missing required parameter: workflow_id",
 		},
 	}
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			// Setup client with mock
 			client := github.NewClient(tc.mockedClient)
-			_, handler := RunWorkflowByFileName(stubGetClientFn(client), translations.NullTranslationHelper)
+			_, handler := RunWorkflow(stubGetClientFn(client), translations.NullTranslationHelper)
 
 			// Create call request
 			request := createMCPRequest(tc.requestArgs)
@@ -289,6 +296,7 @@ func Test_RunWorkflowByFileName(t *testing.T) {
 			err = json.Unmarshal([]byte(textContent.Text), &response)
 			require.NoError(t, err)
 			assert.Equal(t, "Workflow run has been queued", response["message"])
+			assert.Contains(t, response, "workflow_type")
 		})
 	}
 }

pkg/github/tools.go

@@ -125,7 +125,6 @@ func DefaultToolsetGroup(readOnly bool, getClient GetClientFn, getGQLClient GetG
 		).
 		AddWriteTools(
 			toolsets.NewServerTool(RunWorkflow(getClient, t)),
-			toolsets.NewServerTool(RunWorkflowByFileName(getClient, t)),
 			toolsets.NewServerTool(RerunWorkflowRun(getClient, t)),
 			toolsets.NewServerTool(RerunFailedJobs(getClient, t)),
 			toolsets.NewServerTool(CancelWorkflowRun(getClient, t)),