Add API Host interface to resolve URLs dynamically

Author: omgitsads

internal/ghmcp/server.go

@@ -36,12 +36,32 @@ type githubClients struct {
 }
 
 // createGitHubClients creates all the GitHub API clients needed by the server.
-func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHost) (*githubClients, error) {
+func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolver) (*githubClients, error) {
+	restURL, err := apiHost.BaseRESTURL(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get base REST URL: %w", err)
+	}
+
+	uploadURL, err := apiHost.UploadURL(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get upload URL: %w", err)
+	}
+
+	graphQLURL, err := apiHost.GraphqlURL(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get GraphQL URL: %w", err)
+	}
+
+	rawURL, err := apiHost.RawURL(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get Raw URL: %w", err)
+	}
+
 	// Construct REST client
 	restClient := gogithub.NewClient(nil).WithAuthToken(cfg.Token)
 	restClient.UserAgent = fmt.Sprintf("github-mcp-server/%s", cfg.Version)
-	restClient.BaseURL = apiHost.BaseRESTURL
-	restClient.UploadURL = apiHost.UploadURL
+	restClient.BaseURL = restURL
+	restClient.UploadURL = uploadURL
 
 	// Construct GraphQL client
 	// We use NewEnterpriseClient unconditionally since we already parsed the API host
@@ -51,10 +71,11 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHost) (*gi
 			Token:     cfg.Token,
 		},
 	}
-	gqlClient := githubv4.NewEnterpriseClient(apiHost.GraphqlURL.String(), gqlHTTPClient)
+
+	gqlClient := githubv4.NewEnterpriseClient(graphQLURL.String(), gqlHTTPClient)
 
 	// Create raw content client (shares REST client's HTTP transport)
-	rawClient := raw.NewClient(restClient, apiHost.RawURL)
+	rawClient := raw.NewClient(restClient, rawURL)
 
 	// Set up repo access cache for lockdown mode
 	var repoAccessCache *lockdown.RepoAccessCache
@@ -78,7 +99,7 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHost) (*gi
 }
 
 func NewStdioMCPServer(cfg github.MCPServerConfig) (*mcp.Server, error) {
-	apiHost, err := utils.ParseAPIHost(cfg.Host)
+	apiHost, err := utils.NewAPIHost(cfg.Host)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse API host: %w", err)
 	}
@@ -308,13 +329,18 @@ func addUserAgentsMiddleware(cfg github.MCPServerConfig, restClient *gogithub.Cl
 // fetchTokenScopesForHost fetches the OAuth scopes for a token from the GitHub API.
 // It constructs the appropriate API host URL based on the configured host.
 func fetchTokenScopesForHost(ctx context.Context, token, host string) ([]string, error) {
-	apiHost, err := utils.ParseAPIHost(host)
+	apiHost, err := utils.NewAPIHost(host)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse API host: %w", err)
 	}
 
+	baseRestURL, err := apiHost.BaseRESTURL(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get base REST URL: %w", err)
+	}
+
 	fetcher := scopes.NewFetcher(scopes.FetcherOptions{
-		APIHost: apiHost.BaseRESTURL.String(),
+		APIHost: baseRestURL.String(),
 	})
 
 	return fetcher.FetchTokenScopes(ctx, token)

pkg/github/dependencies.go

@@ -213,7 +213,7 @@ type RequestDeps struct {
 	RepoAccessCache *lockdown.RepoAccessCache
 
 	// Static dependencies
-	apiHosts          *utils.APIHost
+	apiHosts          utils.APIHostResolver
 	version           string
 	lockdownMode      bool
 	RepoAccessOpts    []lockdown.RepoAccessOption
@@ -224,7 +224,7 @@ type RequestDeps struct {
 
 // NewRequestDeps creates a RequestDeps with the provided clients and configuration.
 func NewRequestDeps(
-	apiHosts *utils.APIHost,
+	apiHosts utils.APIHostResolver,
 	version string,
 	lockdownMode bool,
 	repoAccessOpts []lockdown.RepoAccessOption,
@@ -252,11 +252,20 @@ func (d *RequestDeps) GetClient(ctx context.Context) (*gogithub.Client, error) {
 	// extract the token from the context
 	token, _ := ghcontext.GetTokenInfo(ctx)
 
+	baseRestURL, err := d.apiHosts.BaseRESTURL(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get base REST URL: %w", err)
+	}
+	uploadURL, err := d.apiHosts.UploadURL(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get upload URL: %w", err)
+	}
+
 	// Construct REST client
 	restClient := gogithub.NewClient(nil).WithAuthToken(token)
 	restClient.UserAgent = fmt.Sprintf("github-mcp-server/%s", d.version)
-	restClient.BaseURL = d.apiHosts.BaseRESTURL
-	restClient.UploadURL = d.apiHosts.UploadURL
+	restClient.BaseURL = baseRestURL
+	restClient.UploadURL = uploadURL
 	return restClient, nil
 }
 
@@ -277,7 +286,13 @@ func (d *RequestDeps) GetGQLClient(ctx context.Context) (*githubv4.Client, error
 			Token:     token,
 		},
 	}
-	gqlClient := githubv4.NewEnterpriseClient(d.apiHosts.GraphqlURL.String(), gqlHTTPClient)
+
+	graphqlURL, err := d.apiHosts.GraphqlURL(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get GraphQL URL: %w", err)
+	}
+
+	gqlClient := githubv4.NewEnterpriseClient(graphqlURL.String(), gqlHTTPClient)
 	d.GQLClient = gqlClient
 	return gqlClient, nil
 }
@@ -293,7 +308,12 @@ func (d *RequestDeps) GetRawClient(ctx context.Context) (*raw.Client, error) {
 		return nil, err
 	}
 
-	rawClient := raw.NewClient(client, d.apiHosts.RawURL)
+	rawURL, err := d.apiHosts.RawURL(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get Raw URL: %w", err)
+	}
+
+	rawClient := raw.NewClient(client, rawURL)
 	d.RawClient = rawClient
 
 	return rawClient, nil

pkg/http/handler.go

@@ -9,53 +9,35 @@ import (
 	"github.com/github/github-mcp-server/pkg/http/headers"
 	"github.com/github/github-mcp-server/pkg/http/middleware"
 	"github.com/github/github-mcp-server/pkg/inventory"
-	"github.com/github/github-mcp-server/pkg/lockdown"
 	"github.com/github/github-mcp-server/pkg/translations"
-	"github.com/github/github-mcp-server/pkg/utils"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
 type InventoryFactoryFunc func(r *http.Request) *inventory.Inventory
 
 type HTTPMcpHandler struct {
 	config               *HTTPServerConfig
-	apiHosts             utils.APIHost
+	deps                 github.ToolDependencies
 	logger               *slog.Logger
 	t                    translations.TranslationHelperFunc
-	repoAccessOpts       []lockdown.RepoAccessOption
 	inventoryFactoryFunc InventoryFactoryFunc
 }
 
 func NewHTTPMcpHandler(cfg *HTTPServerConfig,
+	deps github.ToolDependencies,
 	t translations.TranslationHelperFunc,
-	apiHosts *utils.APIHost,
-	repoAccessOptions []lockdown.RepoAccessOption,
 	logger *slog.Logger,
 	inventoryFactory InventoryFactoryFunc) *HTTPMcpHandler {
 	return &HTTPMcpHandler{
 		config:               cfg,
-		apiHosts:             *apiHosts,
+		deps:                 deps,
 		logger:               logger,
 		t:                    t,
-		repoAccessOpts:       repoAccessOptions,
 		inventoryFactoryFunc: inventoryFactory,
 	}
 }
 
 func (s *HTTPMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Set up repo access cache for lockdown mode
-	deps := github.NewRequestDeps(
-		&s.apiHosts,
-		s.config.Version,
-		s.config.LockdownMode,
-		s.repoAccessOpts,
-		s.t,
-		github.FeatureFlags{
-			LockdownMode: s.config.LockdownMode,
-		},
-		s.config.ContentWindowSize,
-	)
-
 	inventory := s.inventoryFactoryFunc(r)
 
 	ghServer, err := github.NewMCPServer(&github.MCPServerConfig{
@@ -65,7 +47,7 @@ func (s *HTTPMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		ContentWindowSize: s.config.ContentWindowSize,
 		Logger:            s.logger,
 		RepoAccessTTL:     s.config.RepoAccessCacheTTL,
-	}, deps, inventory)
+	}, s.deps, inventory)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 	}

pkg/http/server.go

@@ -11,6 +11,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/github/github-mcp-server/pkg/github"
 	"github.com/github/github-mcp-server/pkg/lockdown"
 	"github.com/github/github-mcp-server/pkg/translations"
 	"github.com/github/github-mcp-server/pkg/utils"
@@ -70,7 +71,7 @@ func RunHTTPServer(cfg HTTPServerConfig) error {
 	logger := slog.New(slogHandler)
 	logger.Info("starting server", "version", cfg.Version, "host", cfg.Host, "lockdownEnabled", cfg.LockdownMode)
 
-	apiHost, err := utils.ParseAPIHost(cfg.Host)
+	apiHost, err := utils.NewAPIHost(cfg.Host)
 	if err != nil {
 		return fmt.Errorf("failed to parse API host: %w", err)
 	}
@@ -82,7 +83,19 @@ func RunHTTPServer(cfg HTTPServerConfig) error {
 		repoAccessOpts = append(repoAccessOpts, lockdown.WithTTL(*cfg.RepoAccessCacheTTL))
 	}
 
-	handler := NewHTTPMcpHandler(&cfg, t, &apiHost, repoAccessOpts, logger, DefaultInventoryFactory(&cfg, t, nil))
+	deps := github.NewRequestDeps(
+		apiHost,
+		cfg.Version,
+		cfg.LockdownMode,
+		repoAccessOpts,
+		t,
+		github.FeatureFlags{
+			LockdownMode: cfg.LockdownMode,
+		},
+		cfg.ContentWindowSize,
+	)
+
+	handler := NewHTTPMcpHandler(&cfg, deps, t, logger, DefaultInventoryFactory(&cfg, t, nil))
 
 	r := chi.NewRouter()
 	r.Mount("/", handler)

pkg/utils/api.go

@@ -1,18 +1,55 @@
 package utils
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 )
 
+type APIHostResolver interface {
+	BaseRESTURL(ctx context.Context) (*url.URL, error)
+	GraphqlURL(ctx context.Context) (*url.URL, error)
+	UploadURL(ctx context.Context) (*url.URL, error)
+	RawURL(ctx context.Context) (*url.URL, error)
+}
+
 type APIHost struct {
-	BaseRESTURL *url.URL
-	GraphqlURL  *url.URL
-	UploadURL   *url.URL
-	RawURL      *url.URL
+	restURL   *url.URL
+	gqlURL    *url.URL
+	uploadURL *url.URL
+	rawURL    *url.URL
+}
+
+var _ APIHostResolver = APIHost{}
+
+func NewAPIHost(s string) (APIHostResolver, error) {
+	a, err := parseAPIHost(s)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return a, nil
+}
+
+// APIHostResolver implementation
+func (a APIHost) BaseRESTURL(_ context.Context) (*url.URL, error) {
+	return a.restURL, nil
+}
+
+func (a APIHost) GraphqlURL(_ context.Context) (*url.URL, error) {
+	return a.gqlURL, nil
+}
+
+func (a APIHost) UploadURL(_ context.Context) (*url.URL, error) {
+	return a.uploadURL, nil
+}
+
+func (a APIHost) RawURL(_ context.Context) (*url.URL, error) {
+	return a.rawURL, nil
 }
 
 func newDotcomHost() (APIHost, error) {
@@ -37,10 +74,10 @@ func newDotcomHost() (APIHost, error) {
 	}
 
 	return APIHost{
-		BaseRESTURL: baseRestURL,
-		GraphqlURL:  gqlURL,
-		UploadURL:   uploadURL,
-		RawURL:      rawURL,
+		restURL:   baseRestURL,
+		gqlURL:    gqlURL,
+		uploadURL: uploadURL,
+		rawURL:    rawURL,
 	}, nil
 }
 
@@ -76,10 +113,10 @@ func newGHECHost(hostname string) (APIHost, error) {
 	}
 
 	return APIHost{
-		BaseRESTURL: restURL,
-		GraphqlURL:  gqlURL,
-		UploadURL:   uploadURL,
-		RawURL:      rawURL,
+		restURL:   restURL,
+		gqlURL:    gqlURL,
+		uploadURL: uploadURL,
+		rawURL:    rawURL,
 	}, nil
 }
 
@@ -128,10 +165,10 @@ func newGHESHost(hostname string) (APIHost, error) {
 	}
 
 	return APIHost{
-		BaseRESTURL: restURL,
-		GraphqlURL:  gqlURL,
-		UploadURL:   uploadURL,
-		RawURL:      rawURL,
+		restURL:   restURL,
+		gqlURL:    gqlURL,
+		uploadURL: uploadURL,
+		rawURL:    rawURL,
 	}, nil
 }
 
@@ -159,7 +196,7 @@ func checkSubdomainIsolation(scheme, hostname string) bool {
 }
 
 // Note that this does not handle ports yet, so development environments are out.
-func ParseAPIHost(s string) (APIHost, error) {
+func parseAPIHost(s string) (APIHost, error) {
 	if s == "" {
 		return newDotcomHost()
 	}