feat: add support for running workflows by ID and filename in GitHub Actions tools

gabornyergesX · gabornyergesX · commit deb66ce6b678 · 2025-06-17T05:43:57.000+02:00
- Introduced a new tool, RunWorkflowByFileName, to allow users to run workflows using the workflow filename.
- Updated the existing RunWorkflow tool to accept a numeric workflow ID instead of a filename.
- Enhanced tests to cover scenarios for both running workflows by ID and filename, including error handling for missing parameters.
- Improved tool descriptions for clarity and usability.
diff --git a/pkg/github/actions.go b/pkg/github/actions.go
@@ -229,24 +229,24 @@ func ListWorkflowRuns(getClient GetClientFn, t translations.TranslationHelperFun
 		}
 }
 
-// RunWorkflow creates a tool to run an Actions workflow
+// RunWorkflow creates a tool to run an Actions workflow by workflow ID
 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")),
+			mcp.WithDescription(t("TOOL_RUN_WORKFLOW_DESCRIPTION", "Run an Actions workflow by workflow ID")),
 			mcp.WithToolAnnotation(mcp.ToolAnnotation{
 				ReadOnlyHint: ToBoolPtr(false),
 			}),
 			mcp.WithString("owner",
 				mcp.Required(),
-				mcp.Description("The account owner of the repository. The name is not case sensitive."),
+				mcp.Description("Repository owner"),
 			),
 			mcp.WithString("repo",
 				mcp.Required(),
 				mcp.Description("Repository name"),
 			),
-			mcp.WithString("workflow_file",
+			mcp.WithNumber("workflow_id",
 				mcp.Required(),
-				mcp.Description("The workflow ID or workflow file name"),
+				mcp.Description("The workflow ID (numeric identifier)"),
 			),
 			mcp.WithString("ref",
 				mcp.Required(),
@@ -265,10 +265,11 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
-			workflowFile, err := RequiredParam[string](request, "workflow_file")
+			workflowIDInt, err := RequiredInt(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
@@ -292,15 +293,17 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 				Inputs: inputs,
 			}
 
-			resp, err := client.Actions.CreateWorkflowDispatchEventByFileName(ctx, owner, repo, workflowFile, event)
+			// 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":    workflowFile,
+				"workflow_id": workflowID,
 				"ref":         ref,
 				"inputs":      inputs,
 				"status":      resp.Status,
@@ -316,6 +319,93 @@ func RunWorkflow(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 		}
 }
 
+// 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{
+				ReadOnlyHint: ToBoolPtr(false),
+			}),
+			mcp.WithString("owner",
+				mcp.Required(),
+				mcp.Description("Repository owner"),
+			),
+			mcp.WithString("repo",
+				mcp.Required(),
+				mcp.Description("Repository name"),
+			),
+			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)
+			}
+
+			event := github.CreateWorkflowDispatchEventRequest{
+				Ref:    ref,
+				Inputs: inputs,
+			}
+
+			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,
+				"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
+		}
+}
+
 // GetWorkflowRun creates a tool to get details of a specific workflow run
 func GetWorkflowRun(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("get_workflow_run",
diff --git a/pkg/github/actions_test.go b/pkg/github/actions_test.go
@@ -134,6 +134,90 @@ func Test_RunWorkflow(t *testing.T) {
 	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_id")
+	assert.Contains(t, tool.InputSchema.Properties, "ref")
+	assert.Contains(t, tool.InputSchema.Properties, "inputs")
+	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo", "workflow_id", "ref"})
+
+	tests := []struct {
+		name           string
+		mockedClient   *http.Client
+		requestArgs    map[string]any
+		expectError    bool
+		expectedErrMsg string
+	}{
+		{
+			name: "successful workflow run",
+			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": float64(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_id",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup client with mock
+			client := github.NewClient(tc.mockedClient)
+			_, handler := RunWorkflow(stubGetClientFn(client), translations.NullTranslationHelper)
+
+			// Create call request
+			request := createMCPRequest(tc.requestArgs)
+
+			// Call handler
+			result, err := handler(context.Background(), request)
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expectError, result.IsError)
+
+			// Parse the result and get the text content if no error
+			textContent := getTextResult(t, result)
+
+			if tc.expectedErrMsg != "" {
+				assert.Equal(t, tc.expectedErrMsg, textContent.Text)
+				return
+			}
+
+			// Unmarshal and verify the result
+			var response map[string]any
+			err = json.Unmarshal([]byte(textContent.Text), &response)
+			require.NoError(t, err)
+			assert.Equal(t, "Workflow run has been queued", response["message"])
+		})
+	}
+}
+
+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")
@@ -147,7 +231,7 @@ func Test_RunWorkflow(t *testing.T) {
 		expectedErrMsg string
 	}{
 		{
-			name: "successful workflow run",
+			name: "successful workflow run by filename",
 			mockedClient: mock.NewMockedHTTPClient(
 				mock.WithRequestMatchHandler(
 					mock.PostReposActionsWorkflowsDispatchesByOwnerByRepoByWorkflowId,
@@ -181,7 +265,7 @@ func Test_RunWorkflow(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			// Setup client with mock
 			client := github.NewClient(tc.mockedClient)
-			_, handler := RunWorkflow(stubGetClientFn(client), translations.NullTranslationHelper)
+			_, handler := RunWorkflowByFileName(stubGetClientFn(client), translations.NullTranslationHelper)
 
 			// Create call request
 			request := createMCPRequest(tc.requestArgs)
diff --git a/pkg/github/tools.go b/pkg/github/tools.go
@@ -125,6 +125,7 @@ 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)),
