Merge branch 'main' into issue-461

Author: aryasoni98

README.md

@@ -278,12 +278,13 @@ docker run -i --rm \
   ghcr.io/github/github-mcp-server
 ```
 
-## GitHub Enterprise Server
+## GitHub Enterprise Server and Enterprise Cloud with data residency (ghe.com)
 
 The flag `--gh-host` and the environment variable `GITHUB_HOST` can be used to set
-the GitHub Enterprise Server hostname.
-Prefix the hostname with the `https://` URI scheme, as it otherwise defaults to `http://` which GitHub Enterprise Server does not support.
+the hostname for GitHub Enterprise Server or GitHub Enterprise Cloud with data residency.
 
+- For GitHub Enterprise Server, prefix the hostname with the `https://` URI scheme, as it otherwise defaults to `http://`, which GitHub Enterprise Server does not support.
+- For GitHub Enterprise Cloud with data residency, use `https://YOURSUBDOMAIN.ghe.com` as the hostname.
 ``` json
 "github": {
     "command": "docker",
@@ -299,7 +300,7 @@ Prefix the hostname with the `https://` URI scheme, as it otherwise defaults to
     ],
     "env": {
         "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}",
-        "GITHUB_HOST": "https://<your GHES domain name>"
+        "GITHUB_HOST": "https://<your GHES or ghe.com domain name>"
     }
 }
 ```

internal/ghmcp/server.go

@@ -113,26 +113,22 @@ func NewMCPServer(cfg MCPServerConfig) (*server.MCPServer, error) {
 	}
 
 	// Create default toolsets
-	toolsets, err := github.InitToolsets(
-		enabledToolsets,
-		cfg.ReadOnly,
-		getClient,
-		getGQLClient,
-		cfg.Translator,
-	)
+	tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, cfg.Translator)
+	err = tsg.EnableToolsets(enabledToolsets)
+
 	if err != nil {
-		return nil, fmt.Errorf("failed to initialize toolsets: %w", err)
+		return nil, fmt.Errorf("failed to enable toolsets: %w", err)
 	}
 
 	context := github.InitContextToolset(getClient, cfg.Translator)
 	github.RegisterResources(ghServer, getClient, cfg.Translator)
 
 	// Register the tools with the server
-	toolsets.RegisterTools(ghServer)
+	tsg.RegisterTools(ghServer)
 	context.RegisterTools(ghServer)
 
 	if cfg.DynamicToolsets {
-		dynamic := github.InitDynamicToolset(ghServer, toolsets, cfg.Translator)
+		dynamic := github.InitDynamicToolset(ghServer, tsg, cfg.Translator)
 		dynamic.RegisterTools(ghServer)
 	}
 

pkg/github/search.go

@@ -146,6 +146,19 @@ func SearchCode(getClient GetClientFn, t translations.TranslationHelperFunc) (to
 		}
 }
 
+type MinimalUser struct {
+	Login      string `json:"login"`
+	ID         int64  `json:"id,omitempty"`
+	ProfileURL string `json:"profile_url,omitempty"`
+	AvatarURL  string `json:"avatar_url,omitempty"`
+}
+
+type MinimalSearchUsersResult struct {
+	TotalCount        int           `json:"total_count"`
+	IncompleteResults bool          `json:"incomplete_results"`
+	Items             []MinimalUser `json:"items"`
+}
+
 // SearchUsers creates a tool to search for GitHub users.
 func SearchUsers(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("search_users",
@@ -200,7 +213,7 @@ func SearchUsers(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
 			}
 
-			result, resp, err := client.Search.Users(ctx, query, opts)
+			result, resp, err := client.Search.Users(ctx, "type:user "+query, opts)
 			if err != nil {
 				return nil, fmt.Errorf("failed to search users: %w", err)
 			}
@@ -214,11 +227,28 @@ func SearchUsers(getClient GetClientFn, t translations.TranslationHelperFunc) (t
 				return mcp.NewToolResultError(fmt.Sprintf("failed to search users: %s", string(body))), nil
 			}
 
-			r, err := json.Marshal(result)
+			minimalUsers := make([]MinimalUser, 0, len(result.Users))
+			for _, user := range result.Users {
+				mu := MinimalUser{
+					Login:      user.GetLogin(),
+					ID:         user.GetID(),
+					ProfileURL: user.GetHTMLURL(),
+					AvatarURL:  user.GetAvatarURL(),
+				}
+
+				minimalUsers = append(minimalUsers, mu)
+			}
+
+			minimalResp := MinimalSearchUsersResult{
+				TotalCount:        result.GetTotal(),
+				IncompleteResults: result.GetIncompleteResults(),
+				Items:             minimalUsers,
+			}
+
+			r, err := json.Marshal(minimalResp)
 			if err != nil {
 				return nil, fmt.Errorf("failed to marshal response: %w", err)
 			}
-
 			return mcp.NewToolResultText(string(r)), nil
 		}
 }

pkg/github/search_test.go

@@ -335,18 +335,13 @@ func Test_SearchUsers(t *testing.T) {
 				ID:        github.Ptr(int64(1001)),
 				HTMLURL:   github.Ptr("https://github.com/user1"),
 				AvatarURL: github.Ptr("https://avatars.githubusercontent.com/u/1001"),
-				Type:      github.Ptr("User"),
-				Followers: github.Ptr(100),
-				Following: github.Ptr(50),
 			},
 			{
 				Login:     github.Ptr("user2"),
 				ID:        github.Ptr(int64(1002)),
 				HTMLURL:   github.Ptr("https://github.com/user2"),
 				AvatarURL: github.Ptr("https://avatars.githubusercontent.com/u/1002"),
 				Type:      github.Ptr("User"),
-				Followers: github.Ptr(200),
-				Following: github.Ptr(75),
 			},
 		},
 	}
@@ -365,7 +360,7 @@ func Test_SearchUsers(t *testing.T) {
 				mock.WithRequestMatchHandler(
 					mock.GetSearchUsers,
 					expectQueryParams(t, map[string]string{
-						"q":        "location:finland language:go",
+						"q":        "type:user location:finland language:go",
 						"sort":     "followers",
 						"order":    "desc",
 						"page":     "1",
@@ -391,7 +386,7 @@ func Test_SearchUsers(t *testing.T) {
 				mock.WithRequestMatchHandler(
 					mock.GetSearchUsers,
 					expectQueryParams(t, map[string]string{
-						"q":        "location:finland language:go",
+						"q":        "type:user location:finland language:go",
 						"page":     "1",
 						"per_page": "30",
 					}).andThen(
@@ -451,19 +446,17 @@ func Test_SearchUsers(t *testing.T) {
 			textContent := getTextResult(t, result)
 
 			// Unmarshal and verify the result
-			var returnedResult github.UsersSearchResult
+			var returnedResult MinimalSearchUsersResult
 			err = json.Unmarshal([]byte(textContent.Text), &returnedResult)
 			require.NoError(t, err)
-			assert.Equal(t, *tc.expectedResult.Total, *returnedResult.Total)
-			assert.Equal(t, *tc.expectedResult.IncompleteResults, *returnedResult.IncompleteResults)
-			assert.Len(t, returnedResult.Users, len(tc.expectedResult.Users))
-			for i, user := range returnedResult.Users {
-				assert.Equal(t, *tc.expectedResult.Users[i].Login, *user.Login)
-				assert.Equal(t, *tc.expectedResult.Users[i].ID, *user.ID)
-				assert.Equal(t, *tc.expectedResult.Users[i].HTMLURL, *user.HTMLURL)
-				assert.Equal(t, *tc.expectedResult.Users[i].AvatarURL, *user.AvatarURL)
-				assert.Equal(t, *tc.expectedResult.Users[i].Type, *user.Type)
-				assert.Equal(t, *tc.expectedResult.Users[i].Followers, *user.Followers)
+			assert.Equal(t, *tc.expectedResult.Total, returnedResult.TotalCount)
+			assert.Equal(t, *tc.expectedResult.IncompleteResults, returnedResult.IncompleteResults)
+			assert.Len(t, returnedResult.Items, len(tc.expectedResult.Users))
+			for i, user := range returnedResult.Items {
+				assert.Equal(t, *tc.expectedResult.Users[i].Login, user.Login)
+				assert.Equal(t, *tc.expectedResult.Users[i].ID, user.ID)
+				assert.Equal(t, *tc.expectedResult.Users[i].HTMLURL, user.ProfileURL)
+				assert.Equal(t, *tc.expectedResult.Users[i].AvatarURL, user.AvatarURL)
 			}
 		})
 	}

pkg/github/tools.go

@@ -15,8 +15,7 @@ type GetGQLClientFn func(context.Context) (*githubv4.Client, error)
 
 var DefaultTools = []string{"all"}
 
-func InitToolsets(passedToolsets []string, readOnly bool, getClient GetClientFn, getGQLClient GetGQLClientFn, t translations.TranslationHelperFunc) (*toolsets.ToolsetGroup, error) {
-	// Create a new toolset group
+func DefaultToolsetGroup(readOnly bool, getClient GetClientFn, getGQLClient GetGQLClientFn, t translations.TranslationHelperFunc) *toolsets.ToolsetGroup {
 	tsg := toolsets.NewToolsetGroup(readOnly)
 
 	// Define all available features with their default state (disabled)
@@ -118,13 +117,8 @@ func InitToolsets(passedToolsets []string, readOnly bool, getClient GetClientFn,
 	tsg.AddToolset(secretProtection)
 	tsg.AddToolset(notifications)
 	tsg.AddToolset(experiments)
-	// Enable the requested features
 
-	if err := tsg.EnableToolsets(passedToolsets); err != nil {
-		return nil, err
-	}
-
-	return tsg, nil
+	return tsg
 }
 
 func InitContextToolset(getClient GetClientFn, t translations.TranslationHelperFunc) *toolsets.Toolset {

pkg/toolsets/toolsets.go

@@ -7,6 +7,28 @@ import (
 	"github.com/mark3labs/mcp-go/server"
 )
 
+type ToolsetDoesNotExistError struct {
+	Name string
+}
+
+func (e *ToolsetDoesNotExistError) Error() string {
+	return fmt.Sprintf("toolset %s does not exist", e.Name)
+}
+
+func (e *ToolsetDoesNotExistError) Is(target error) bool {
+	if target == nil {
+		return false
+	}
+	if _, ok := target.(*ToolsetDoesNotExistError); ok {
+		return true
+	}
+	return false
+}
+
+func NewToolsetDoesNotExistError(name string) *ToolsetDoesNotExistError {
+	return &ToolsetDoesNotExistError{Name: name}
+}
+
 func NewServerTool(tool mcp.Tool, handler server.ToolHandlerFunc) server.ServerTool {
 	return server.ServerTool{Tool: tool, Handler: handler}
 }
@@ -150,7 +172,7 @@ func (tg *ToolsetGroup) EnableToolsets(names []string) error {
 func (tg *ToolsetGroup) EnableToolset(name string) error {
 	toolset, exists := tg.Toolsets[name]
 	if !exists {
-		return fmt.Errorf("toolset %s does not exist", name)
+		return NewToolsetDoesNotExistError(name)
 	}
 	toolset.Enabled = true
 	tg.Toolsets[name] = toolset
@@ -162,3 +184,11 @@ func (tg *ToolsetGroup) RegisterTools(s *server.MCPServer) {
 		toolset.RegisterTools(s)
 	}
 }
+
+func (tg *ToolsetGroup) GetToolset(name string) (*Toolset, error) {
+	toolset, exists := tg.Toolsets[name]
+	if !exists {
+		return nil, NewToolsetDoesNotExistError(name)
+	}
+	return toolset, nil
+}

pkg/toolsets/toolsets_test.go

@@ -1,6 +1,7 @@
 package toolsets
 
 import (
+	"errors"
 	"testing"
 )
 
@@ -151,6 +152,9 @@ func TestEnableToolsets(t *testing.T) {
 	if err == nil {
 		t.Error("Expected error when enabling list with non-existent toolset")
 	}
+	if !errors.Is(err, NewToolsetDoesNotExistError("non-existent")) {
+		t.Errorf("Expected ToolsetDoesNotExistError when enabling non-existent toolset, got: %v", err)
+	}
 
 	// Test with empty list
 	err = tsg.EnableToolsets([]string{})
@@ -207,7 +211,7 @@ func TestEnableEverything(t *testing.T) {
 func TestIsEnabledWithEverythingOn(t *testing.T) {
 	tsg := NewToolsetGroup(false)
 
-	// Enable "everything"
+	// Enable "all"
 	err := tsg.EnableToolsets([]string{"all"})
 	if err != nil {
 		t.Errorf("Expected no error when enabling 'all', got: %v", err)
@@ -222,3 +226,27 @@ func TestIsEnabledWithEverythingOn(t *testing.T) {
 		t.Error("Expected IsEnabled to return true for any toolset when everythingOn is true")
 	}
 }
+
+func TestToolsetGroup_GetToolset(t *testing.T) {
+	tsg := NewToolsetGroup(false)
+	toolset := NewToolset("my-toolset", "desc")
+	tsg.AddToolset(toolset)
+
+	// Should find the toolset
+	got, err := tsg.GetToolset("my-toolset")
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if got != toolset {
+		t.Errorf("expected to get the same toolset instance")
+	}
+
+	// Should not find a non-existent toolset
+	_, err = tsg.GetToolset("does-not-exist")
+	if err == nil {
+		t.Error("expected error for missing toolset, got nil")
+	}
+	if !errors.Is(err, NewToolsetDoesNotExistError("does-not-exist")) {
+		t.Errorf("expected error to be ToolsetDoesNotExistError, got %v", err)
+	}
+}