feat: allow HTTP default token fallback

Author: cbartz

README.md

@@ -1512,6 +1512,8 @@ GITHUB_ALLOWED_PR_AUTHORS='renovate[bot],github-actions[bot]' ./github-mcp-serve
 
 When set, tools such as `merge_pull_request`, `update_pull_request`, review-write tools, and PR branch updates fetch the target PR and reject the call unless `pr.User.Login` is in the allowlist. Read-only PR tools and `create_pull_request` are not restricted. `actions_run_trigger` is not gated by this setting because it targets a ref rather than a PR number.
 
+In HTTP mode, `GITHUB_PERSONAL_ACCESS_TOKEN` can also be used as a server-side default token for trusted local deployments. Requests with an `Authorization` header still use the request token; requests without one fall back to the configured server token.
+
 ## i18n / Overriding Descriptions
 
 The descriptions of the tools can be overridden by creating a

cmd/github-mcp-server/main.go

@@ -146,6 +146,7 @@ var (
 			httpConfig := ghhttp.ServerConfig{
 				Version:              version,
 				Host:                 viper.GetString("host"),
+				Token:                viper.GetString("personal_access_token"),
 				Port:                 viper.GetInt("port"),
 				BaseURL:              viper.GetString("base-url"),
 				ResourcePath:         viper.GetString("base-path"),

docs/streamable-http.md

@@ -91,3 +91,13 @@ To provide PAT credentials, or to customize server behavior preferences, you can
 ```
 
 See [Remote Server](./remote-server.md) documentation for more details on client configuration options.
+
+### Using a Server-Side Default Token
+
+For trusted local deployments, HTTP mode can use `GITHUB_PERSONAL_ACCESS_TOKEN` as a fallback when a request does not include an `Authorization` header:
+
+```bash
+GITHUB_PERSONAL_ACCESS_TOKEN=ghp_yourtokenhere github-mcp-server http
+```
+
+If a request includes `Authorization: Bearer ...`, that request token takes precedence. If no request token is provided and no server-side token is configured, the server returns `401 Unauthorized`.

pkg/http/handler.go

@@ -127,7 +127,7 @@ func NewHTTPMcpHandler(
 
 func (h *Handler) RegisterMiddleware(r chi.Router) {
 	r.Use(
-		middleware.ExtractUserToken(h.oauthCfg),
+		middleware.ExtractUserToken(h.oauthCfg, h.config.Token),
 		middleware.WithRequestConfig,
 		middleware.WithMCPParse(),
 		middleware.WithPATScopes(h.logger, h.scopeFetcher),

pkg/http/middleware/token.go

@@ -10,7 +10,7 @@ import (
 	"github.com/github/github-mcp-server/pkg/utils"
 )
 
-func ExtractUserToken(oauthCfg *oauth.Config) func(next http.Handler) http.Handler {
+func ExtractUserToken(oauthCfg *oauth.Config, defaultToken ...string) func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			ctx := r.Context()
@@ -27,6 +27,20 @@ func ExtractUserToken(oauthCfg *oauth.Config) func(next http.Handler) http.Handl
 			if err != nil {
 				// For missing Authorization header, return 401 with WWW-Authenticate header per MCP spec
 				if errors.Is(err, utils.ErrMissingAuthorizationHeader) {
+					if len(defaultToken) > 0 && defaultToken[0] != "" {
+						tokenType, err := utils.ParseToken(defaultToken[0])
+						if err != nil {
+							http.Error(w, fmt.Sprintf("default token is invalid: %v", err), http.StatusInternalServerError)
+							return
+						}
+
+						ctx = ghcontext.WithTokenInfo(ctx, &ghcontext.TokenInfo{
+							Token:     defaultToken[0],
+							TokenType: tokenType,
+						})
+						next.ServeHTTP(w, r.WithContext(ctx))
+						return
+					}
 					sendAuthChallenge(w, r, oauthCfg)
 					return
 				}

pkg/http/middleware/token_test.go

@@ -232,6 +232,55 @@ func TestExtractUserToken_NilOAuthConfig(t *testing.T) {
 	assert.Equal(t, utils.TokenTypePersonalAccessToken, capturedTokenInfo.TokenType)
 }
 
+func TestExtractUserToken_DefaultTokenFallback(t *testing.T) {
+	var capturedTokenInfo *ghcontext.TokenInfo
+	var tokenInfoCaptured bool
+
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		capturedTokenInfo, tokenInfoCaptured = ghcontext.GetTokenInfo(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	middleware := ExtractUserToken(nil, "ghp_defaulttokenxxxxxxxxxxxxxxxxxxxxxxxx")
+	handler := middleware(nextHandler)
+
+	req := httptest.NewRequest(http.MethodGet, "/test", nil)
+	rr := httptest.NewRecorder()
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+	require.True(t, tokenInfoCaptured)
+	require.NotNil(t, capturedTokenInfo)
+	assert.Equal(t, utils.TokenTypePersonalAccessToken, capturedTokenInfo.TokenType)
+	assert.Equal(t, "ghp_defaulttokenxxxxxxxxxxxxxxxxxxxxxxxx", capturedTokenInfo.Token)
+}
+
+func TestExtractUserToken_RequestTokenOverridesDefaultToken(t *testing.T) {
+	var capturedTokenInfo *ghcontext.TokenInfo
+	var tokenInfoCaptured bool
+
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		capturedTokenInfo, tokenInfoCaptured = ghcontext.GetTokenInfo(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	middleware := ExtractUserToken(nil, "ghp_defaulttokenxxxxxxxxxxxxxxxxxxxxxxxx")
+	handler := middleware(nextHandler)
+
+	req := httptest.NewRequest(http.MethodGet, "/test", nil)
+	req.Header.Set(headers.AuthorizationHeader, "Bearer gho_requesttokenxxxxxxxxxxxxxxxxxxxxxxxx")
+	rr := httptest.NewRecorder()
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+	require.True(t, tokenInfoCaptured)
+	require.NotNil(t, capturedTokenInfo)
+	assert.Equal(t, utils.TokenTypeOAuthAccessToken, capturedTokenInfo.TokenType)
+	assert.Equal(t, "gho_requesttokenxxxxxxxxxxxxxxxxxxxxxxxx", capturedTokenInfo.Token)
+}
+
 func TestExtractUserToken_MissingAuthHeader_WWWAuthenticateFormat(t *testing.T) {
 	oauthCfg := &oauth.Config{
 		BaseURL:             "https://api.example.com",

pkg/http/server.go

@@ -32,6 +32,10 @@ type ServerConfig struct {
 	// GitHub Host to target for API requests (e.g. github.com or github.enterprise.com)
 	Host string
 
+	// GitHub Token to use for requests that do not provide Authorization.
+	// If empty, HTTP requests must provide their own Authorization header.
+	Token string
+
 	// Port to listen on (default: 8082)
 	Port int
 

pkg/utils/token.go

@@ -60,16 +60,22 @@ func ParseAuthorizationHeader(req *http.Request) (tokenType TokenType, token str
 		}
 	}
 
+	tokenType, err := ParseToken(token)
+	return tokenType, token, err
+}
+
+// ParseToken identifies a GitHub API token type from the token value.
+func ParseToken(token string) (TokenType, error) {
 	for prefix, tokenType := range supportedGitHubPrefixes {
 		if strings.HasPrefix(token, prefix) {
-			return tokenType, token, nil
+			return tokenType, nil
 		}
 	}
 
 	matchesOldTokenPattern := oldPatternRegexp.MatchString(token)
 	if matchesOldTokenPattern {
-		return TokenTypePersonalAccessToken, token, nil
+		return TokenTypePersonalAccessToken, nil
 	}
 
-	return 0, "", ErrBadAuthorizationHeader
+	return 0, ErrBadAuthorizationHeader
 }