fix some linter errors, make port configurable

kerobbi · kerobbi · commit ad7a49a83987 · 2026-01-19T11:58:39.000Z
diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go
@@ -98,6 +98,7 @@ var (
 			httpConfig := ghhttp.HTTPServerConfig{
 				Version:              version,
 				Host:                 viper.GetString("host"),
+				Port:                 viper.GetInt("port"),
 				ExportTranslations:   viper.GetBool("export-translations"),
 				EnableCommandLogging: viper.GetBool("enable-command-logging"),
 				LogFilePath:          viper.GetString("log-file"),
@@ -128,6 +129,7 @@ func init() {
 	rootCmd.PersistentFlags().Int("content-window-size", 5000, "Specify the content window size")
 	rootCmd.PersistentFlags().Bool("lockdown-mode", false, "Enable lockdown mode")
 	rootCmd.PersistentFlags().Duration("repo-access-cache-ttl", 5*time.Minute, "Override the repo access cache TTL (e.g. 1m, 0s to disable)")
+	rootCmd.PersistentFlags().Int("port", 8082, "HTTP server port")
 
 	// Bind flag to viper
 	_ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))
@@ -142,6 +144,7 @@ func init() {
 	_ = viper.BindPFlag("content-window-size", rootCmd.PersistentFlags().Lookup("content-window-size"))
 	_ = viper.BindPFlag("lockdown-mode", rootCmd.PersistentFlags().Lookup("lockdown-mode"))
 	_ = viper.BindPFlag("repo-access-cache-ttl", rootCmd.PersistentFlags().Lookup("repo-access-cache-ttl"))
+	_ = viper.BindPFlag("port", rootCmd.PersistentFlags().Lookup("port"))
 
 	// Add subcommands
 	rootCmd.AddCommand(stdioCmd)
diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go
@@ -36,7 +36,7 @@ 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.APIHost) (*githubClients, error) {
 	// Construct REST client
 	restClient := gogithub.NewClient(nil).WithAuthToken(cfg.Token)
 	restClient.UserAgent = fmt.Sprintf("github-mcp-server/%s", cfg.Version)
diff --git a/pkg/github/dependencies.go b/pkg/github/dependencies.go
@@ -213,7 +213,7 @@ type RequestDeps struct {
 	RepoAccessCache *lockdown.RepoAccessCache
 
 	// Static dependencies
-	apiHosts          *utils.ApiHost
+	apiHosts          *utils.APIHost
 	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.APIHost,
 	version string,
 	lockdownMode bool,
 	repoAccessOpts []lockdown.RepoAccessOption,
diff --git a/pkg/github/server_test.go b/pkg/github/server_test.go
@@ -123,8 +123,14 @@ func TestNewMCPServer_CreatesSuccessfully(t *testing.T) {
 
 	deps := stubDeps{}
 
+	// Build inventory
+	inv := NewInventory(cfg.Translator).
+		WithDeprecatedAliases(DeprecatedToolAliases).
+		WithToolsets(cfg.EnabledToolsets).
+		Build()
+
 	// Create the server
-	server, err := NewMCPServer(&cfg, deps)
+	server, err := NewMCPServer(&cfg, deps, inv)
 	require.NoError(t, err, "expected server creation to succeed")
 	require.NotNil(t, server, "expected server to be non-nil")
 
diff --git a/pkg/http/handler.go b/pkg/http/handler.go
@@ -16,22 +16,22 @@ import (
 
 type InventoryFactoryFunc func(r *http.Request) *inventory.Inventory
 
-type HttpMcpHandler struct {
+type HTTPMcpHandler struct {
 	config               *HTTPServerConfig
-	apiHosts             utils.ApiHost
+	apiHosts             utils.APIHost
 	logger               *slog.Logger
 	t                    translations.TranslationHelperFunc
 	repoAccessOpts       []lockdown.RepoAccessOption
 	inventoryFactoryFunc InventoryFactoryFunc
 }
 
-func NewHttpMcpHandler(cfg *HTTPServerConfig,
+func NewHTTPMcpHandler(cfg *HTTPServerConfig,
 	t translations.TranslationHelperFunc,
-	apiHosts *utils.ApiHost,
+	apiHosts *utils.APIHost,
 	repoAccessOptions []lockdown.RepoAccessOption,
 	logger *slog.Logger,
-	inventoryFactory InventoryFactoryFunc) *HttpMcpHandler {
-	return &HttpMcpHandler{
+	inventoryFactory InventoryFactoryFunc) *HTTPMcpHandler {
+	return &HTTPMcpHandler{
 		config:               cfg,
 		apiHosts:             *apiHosts,
 		logger:               logger,
@@ -41,7 +41,7 @@ func NewHttpMcpHandler(cfg *HTTPServerConfig,
 	}
 }
 
-func (s *HttpMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (s *HTTPMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// Set up repo access cache for lockdown mode
 	deps := github.NewRequestDeps(
 		&s.apiHosts,
diff --git a/pkg/http/server.go b/pkg/http/server.go
@@ -24,6 +24,9 @@ type HTTPServerConfig struct {
 	// GitHub Host to target for API requests (e.g. github.com or github.enterprise.com)
 	Host string
 
+	// Port to listen on (default: 8082)
+	Port int
+
 	// ExportTranslations indicates if we should export translations
 	// See: https://github.com/github/github-mcp-server?tab=readme-ov-file#i18n--overriding-descriptions
 	ExportTranslations bool
@@ -79,14 +82,16 @@ func RunHTTPServer(cfg HTTPServerConfig) error {
 		repoAccessOpts = append(repoAccessOpts, lockdown.WithTTL(*cfg.RepoAccessCacheTTL))
 	}
 
-	handler := NewHttpMcpHandler(&cfg, t, &apiHost, repoAccessOpts, logger, DefaultInventoryFactory(&cfg, t))
+	handler := NewHTTPMcpHandler(&cfg, t, &apiHost, repoAccessOpts, logger, DefaultInventoryFactory(&cfg, t))
 
 	r := chi.NewRouter()
 	r.Mount("/", handler)
 
+	addr := fmt.Sprintf(":%d", cfg.Port)
 	httpSvr := http.Server{
-		Addr:    ":8082",
-		Handler: r,
+		Addr:              addr,
+		Handler:           r,
+		ReadHeaderTimeout: 60 * time.Second,
 	}
 
 	go func() {
@@ -104,7 +109,7 @@ func RunHTTPServer(cfg HTTPServerConfig) error {
 		dumpTranslations()
 	}
 
-	logger.Info("HTTP server listening on :8082")
+	logger.Info("HTTP server listening", "addr", addr)
 	if err := httpSvr.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 		return fmt.Errorf("HTTP server error: %w", err)
 	}
diff --git a/pkg/utils/api.go b/pkg/utils/api.go
@@ -8,95 +8,95 @@ import (
 	"time"
 )
 
-type ApiHost struct {
+type APIHost struct {
 	BaseRESTURL *url.URL
 	GraphqlURL  *url.URL
 	UploadURL   *url.URL
 	RawURL      *url.URL
 }
 
-func newDotcomHost() (ApiHost, error) {
+func newDotcomHost() (APIHost, error) {
 	baseRestURL, err := url.Parse("https://api.github.com/")
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse dotcom REST URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse dotcom REST URL: %w", err)
 	}
 
 	gqlURL, err := url.Parse("https://api.github.com/graphql")
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse dotcom GraphQL URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse dotcom GraphQL URL: %w", err)
 	}
 
 	uploadURL, err := url.Parse("https://uploads.github.com")
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse dotcom Upload URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse dotcom Upload URL: %w", err)
 	}
 
 	rawURL, err := url.Parse("https://raw.githubusercontent.com/")
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse dotcom Raw URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse dotcom Raw URL: %w", err)
 	}
 
-	return ApiHost{
+	return APIHost{
 		BaseRESTURL: baseRestURL,
 		GraphqlURL:  gqlURL,
 		UploadURL:   uploadURL,
 		RawURL:      rawURL,
 	}, nil
 }
 
-func newGHECHost(hostname string) (ApiHost, error) {
+func newGHECHost(hostname string) (APIHost, error) {
 	u, err := url.Parse(hostname)
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHEC URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHEC URL: %w", err)
 	}
 
 	// Unsecured GHEC would be an error
 	if u.Scheme == "http" {
-		return ApiHost{}, fmt.Errorf("GHEC URL must be HTTPS")
+		return APIHost{}, fmt.Errorf("GHEC URL must be HTTPS")
 	}
 
 	restURL, err := url.Parse(fmt.Sprintf("https://api.%s/", u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHEC REST URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHEC REST URL: %w", err)
 	}
 
 	gqlURL, err := url.Parse(fmt.Sprintf("https://api.%s/graphql", u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHEC GraphQL URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHEC GraphQL URL: %w", err)
 	}
 
 	uploadURL, err := url.Parse(fmt.Sprintf("https://uploads.%s", u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHEC Upload URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHEC Upload URL: %w", err)
 	}
 
 	rawURL, err := url.Parse(fmt.Sprintf("https://raw.%s/", u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHEC Raw URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHEC Raw URL: %w", err)
 	}
 
-	return ApiHost{
+	return APIHost{
 		BaseRESTURL: restURL,
 		GraphqlURL:  gqlURL,
 		UploadURL:   uploadURL,
 		RawURL:      rawURL,
 	}, nil
 }
 
-func newGHESHost(hostname string) (ApiHost, error) {
+func newGHESHost(hostname string) (APIHost, error) {
 	u, err := url.Parse(hostname)
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHES URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHES URL: %w", err)
 	}
 
 	restURL, err := url.Parse(fmt.Sprintf("%s://%s/api/v3/", u.Scheme, u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHES REST URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHES REST URL: %w", err)
 	}
 
 	gqlURL, err := url.Parse(fmt.Sprintf("%s://%s/api/graphql", u.Scheme, u.Hostname()))
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHES GraphQL URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHES GraphQL URL: %w", err)
 	}
 
 	// Check if subdomain isolation is enabled
@@ -112,7 +112,7 @@ func newGHESHost(hostname string) (ApiHost, error) {
 		uploadURL, err = url.Parse(fmt.Sprintf("%s://%s/api/uploads/", u.Scheme, u.Hostname()))
 	}
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHES Upload URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHES Upload URL: %w", err)
 	}
 
 	var rawURL *url.URL
@@ -124,10 +124,10 @@ func newGHESHost(hostname string) (ApiHost, error) {
 		rawURL, err = url.Parse(fmt.Sprintf("%s://%s/raw/", u.Scheme, u.Hostname()))
 	}
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("failed to parse GHES Raw URL: %w", err)
+		return APIHost{}, fmt.Errorf("failed to parse GHES Raw URL: %w", err)
 	}
 
-	return ApiHost{
+	return APIHost{
 		BaseRESTURL: restURL,
 		GraphqlURL:  gqlURL,
 		UploadURL:   uploadURL,
@@ -159,18 +159,18 @@ 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()
 	}
 
 	u, err := url.Parse(s)
 	if err != nil {
-		return ApiHost{}, fmt.Errorf("could not parse host as URL: %s", s)
+		return APIHost{}, fmt.Errorf("could not parse host as URL: %s", s)
 	}
 
 	if u.Scheme == "" {
-		return ApiHost{}, fmt.Errorf("host must have a scheme (http or https): %s", s)
+		return APIHost{}, fmt.Errorf("host must have a scheme (http or https): %s", s)
 	}
 
 	if strings.HasSuffix(u.Hostname(), "github.com") {

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ type githubClients struct {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`// createGitHubClients creates all the GitHub API clients needed by the server.`
`39`		`-func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.ApiHost) (*githubClients, error) {`
	`39`	`+func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHost) (*githubClients, error) {`
`40`	`40`	`// Construct REST client`
`41`	`41`	`restClient := gogithub.NewClient(nil).WithAuthToken(cfg.Token)`
`42`	`42`	`restClient.UserAgent = fmt.Sprintf("github-mcp-server/%s", cfg.Version)`