Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 3 additions & 1 deletion docs/oauth-login.md
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,9 @@ published callback port — the server falls back to the
[device-code flow](#headless-and-device-code-fallback).

GitHub App tokens that expire are refreshed transparently using the refresh
token, so long-running sessions keep working without re-authorizing.
token, so long-running sessions keep working without re-authorizing. Concurrent
requests share a refresh. Canceling a request stops its wait while the refresh
can finish and save the rotated token for the session.

## Quick start

Expand Down
8 changes: 6 additions & 2 deletions internal/ghmcp/oauth.go
Original file line number Diff line number Diff line change
Expand Up @@ -92,7 +92,7 @@ func (p *sessionPrompter) PromptForm(ctx context.Context, prompt oauth.Prompt) e
// middleware be exercised with a deterministic fake, since driving the real
// manager to its branches would require standing up live GitHub flows.
type oauthAuthenticator interface {
HasToken() bool
HasTokenContext(ctx context.Context) (bool, error)
Authenticate(ctx context.Context, prompter oauth.Prompter) (*oauth.Outcome, error)
AwaitToken(ctx context.Context, flowID string) (*oauth.Outcome, error)
Cancel(flowID string) bool
Expand Down Expand Up @@ -137,7 +137,11 @@ func createOAuthToolMiddleware(mgr oauthAuthenticator, logger *slog.Logger) inve
}
}

if mgr.HasToken() {
hasToken, err := mgr.HasTokenContext(ctx)
if err != nil {
return nil, err
}
Comment on lines +140 to +143

Copy link
Copy Markdown
Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Addressed in 1419bf09. I added a regression test for the OAuth tool guard that passes an already-canceled request context and verifies that the guard returns context.Canceled with a nil result, skips authentication, and never calls the tool handler.

I verified that the test fails if the guard drops the token-check error or substitutes context.Background() for the request context. The full Windows Go suite, Linux race suite, and lint passed.

if hasToken {
return next(ctx, req)
}
if serverMayInitiateElicitation(req.Session) {
Expand Down
153 changes: 153 additions & 0 deletions internal/ghmcp/oauth_refresh_transport_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,153 @@
package ghmcp

import (
"context"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"

"github.com/github/github-mcp-server/v2/pkg/github"
"github.com/github/github-mcp-server/v2/pkg/http/headers"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestStdioGitHubClientsUseOAuthRequestContext(t *testing.T) {
t.Parallel()

for _, tt := range []struct {
name string
response string
call func(context.Context, *githubClients) error
}{
{
name: "REST", response: `{"login":"octocat"}`,
call: func(ctx context.Context, clients *githubClients) error {
_, _, err := clients.rest.Users.Get(ctx, "")
return err
},
},
{
name: "GraphQL", response: `{"data":{"viewer":{"login":"octocat"}}}`,
call: func(ctx context.Context, clients *githubClients) error {
var query struct{ Viewer struct{ Login string } }
return clients.gql.Query(ctx, &query, nil)
},
},
{
name: "raw", response: "file contents",
call: func(ctx context.Context, clients *githubClients) error {
resp, err := clients.raw.GetRawContent(ctx, "owner", "repo", "file", nil)
if err != nil {
return err
}
return resp.Body.Close()
},
},
} {
t.Run(tt.name, func(t *testing.T) {
var requestCount atomic.Int32
api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
requestCount.Add(1)
assert.Equal(t, "Bearer refreshed-token", req.Header.Get(headers.AuthorizationHeader))
w.Header().Set(headers.ContentTypeHeader, headers.ContentTypeJSON)
_, _ = io.WriteString(w, tt.response)
}))
defer api.Close()

type waitForCancellationKey struct{}
entered := make(chan struct{}, 1)
provider := func(ctx context.Context) (string, error) {
if ctx.Value(waitForCancellationKey{}) == true {
entered <- struct{}{}
<-ctx.Done()
return "", ctx.Err()
}
return "refreshed-token", nil
}
clients, err := createGitHubClients(github.MCPServerConfig{Version: "test"}, newStaticAPIHostResolver(t, api.URL), provider)
require.NoError(t, err)

ctx, stop := context.WithTimeout(t.Context(), 5*time.Second)
defer stop()
blockedCtx, cancel := context.WithCancel(context.WithValue(ctx, waitForCancellationKey{}, true))
defer cancel()
finished := make(chan error, 1)
go func() { finished <- tt.call(blockedCtx, clients) }()
select {
case <-entered:
case err := <-finished:
t.Fatalf("request returned before the OAuth provider saw its context: %v", err)
case <-ctx.Done():
t.Fatal("OAuth provider did not see the request context")
}

require.NoError(t, tt.call(ctx, clients), "the peer should succeed while the first request waits for a token")
cancel()
select {
case err := <-finished:
require.ErrorIs(t, err, context.Canceled)
case <-ctx.Done():
t.Fatal("canceling the request did not stop its token wait")
}
assert.EqualValues(t, 1, requestCount.Load(), "only the healthy peer should reach GitHub")
})
}
}

func TestStdioOAuthTransportClosesRequestBodyOnProviderError(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(t.Context())
cancel()
body := &oauthRequestBody{Reader: strings.NewReader("graphql query")}
req := httptest.NewRequestWithContext(ctx, http.MethodPost, "https://github.example/graphql", body)
base := oauthRoundTripFunc(func(*http.Request) (*http.Response, error) {
t.Fatal("the request reached the underlying transport")
return nil, nil
})
transport := stdioBearerTransport(github.MCPServerConfig{}, base, []string{req.URL.Host}, func(ctx context.Context) (string, error) {
return "", ctx.Err()
})
resp, err := transport.RoundTrip(req)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
require.ErrorIs(t, err, context.Canceled)
assert.Nil(t, resp)
assert.True(t, body.closed)
}

func TestStdioOAuthTransportStripsAuthorizationForUnlistedHost(t *testing.T) {
t.Parallel()
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "https://other.example/file", nil)
req.Header.Set(headers.AuthorizationHeader, "Bearer forwarded-token")
base := oauthRoundTripFunc(func(outgoing *http.Request) (*http.Response, error) {
assert.Empty(t, outgoing.Header.Get(headers.AuthorizationHeader))
return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
})
transport := stdioBearerTransport(github.MCPServerConfig{}, base, []string{"github.example"}, func(context.Context) (string, error) {
return "refreshed-token", nil
})
resp, err := transport.RoundTrip(req)
require.NoError(t, err)
require.NoError(t, resp.Body.Close())
assert.Equal(t, "Bearer forwarded-token", req.Header.Get(headers.AuthorizationHeader), "transport must not modify the caller's request")
}

type oauthRequestBody struct {
io.Reader
closed bool
}

func (b *oauthRequestBody) Close() error {
b.closed = true
return nil
}

type oauthRoundTripFunc func(*http.Request) (*http.Response, error)

func (f oauthRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
23 changes: 20 additions & 3 deletions internal/ghmcp/oauth_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,7 @@ func TestCreateGitHubClientsScopesRESTAndRawTokens(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
apiHost := newStaticAPIHostResolver(t, source.URL)
clients, err := createGitHubClients(tt.cfg, apiHost)
clients, err := createGitHubClients(tt.cfg, apiHost, nil)
require.NoError(t, err)

sourceAuth = ""
Expand Down Expand Up @@ -356,7 +356,9 @@ type fakeAuthenticator struct {
lastCancelFlowID string
}

func (f *fakeAuthenticator) HasToken() bool { return f.hasToken }
func (f *fakeAuthenticator) HasTokenContext(ctx context.Context) (bool, error) {
return f.hasToken, ctx.Err()
}

func (f *fakeAuthenticator) Authenticate(_ context.Context, prompter oauth.Prompter) (*oauth.Outcome, error) {
f.authCalls++
Expand Down Expand Up @@ -401,6 +403,21 @@ func TestCreateOAuthToolMiddleware(t *testing.T) {
assert.Zero(t, fake.authCalls, "authentication must be skipped when a token already exists")
})

t.Run("canceled token check skips authentication and handler", func(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(t.Context())
cancel()

fake := &fakeAuthenticator{}
var called bool
mw := createOAuthToolMiddleware(fake, discardLogger())
res, err := mw(newNext(&called))(ctx, &mcp.CallToolRequest{})
assert.ErrorIs(t, err, context.Canceled)
assert.Nil(t, res)
assert.Zero(t, fake.authCalls, "cancellation must not start authentication")
assert.False(t, called, "cancellation must not run the tool")
})

t.Run("successful authentication proceeds to handler", func(t *testing.T) {
t.Parallel()
fake := &fakeAuthenticator{hasToken: false, outcome: nil, err: nil}
Expand Down Expand Up @@ -690,7 +707,7 @@ func TestCreateGitHubClientsTokenProvider(t *testing.T) {
clients, err := createGitHubClients(github.MCPServerConfig{
Version: "test",
TokenProvider: func() string { return current },
}, apiHost)
}, apiHost, nil)
require.NoError(t, err)

do := func() {
Expand Down
79 changes: 53 additions & 26 deletions internal/ghmcp/server.go
Original file line number Diff line number Diff line change
Expand Up @@ -40,8 +40,41 @@ type githubClients struct {
repoAccess *lockdown.RepoAccessCache
}

type oauthTokenProvider func(context.Context) (string, error)

type oauthBearerTransport struct {
bearer transport.BearerAuthTransport
token oauthTokenProvider
}

func (t *oauthBearerTransport) RoundTrip(req *http.Request) (*http.Response, error) {
token, err := t.token(req.Context())
if err != nil {
if req.Body != nil {
_ = req.Body.Close()
}
return nil, err
}
bearer := t.bearer
bearer.Token = token
return bearer.RoundTrip(req)
}

func stdioBearerTransport(cfg github.MCPServerConfig, base http.RoundTripper, allowedHosts []string, oauthToken oauthTokenProvider) http.RoundTripper {
bearer := transport.BearerAuthTransport{
Transport: base,
Token: cfg.Token,
TokenProvider: cfg.TokenProvider,
AllowedHosts: allowedHosts,
}
if oauthToken == nil {
return &bearer
}
return &oauthBearerTransport{bearer: bearer, token: oauthToken}
}

// createGitHubClients creates all the GitHub API clients needed by the server.
func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolver) (*githubClients, error) {
func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolver, oauthToken oauthTokenProvider) (*githubClients, error) {
restURL, err := apiHost.BaseRESTURL(context.Background())
if err != nil {
return nil, fmt.Errorf("failed to get base REST URL: %w", err)
Expand Down Expand Up @@ -91,25 +124,20 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv
Transport: &transport.ETagTransport{Transport: http.DefaultTransport},
Agent: stdioUserAgent(cfg, nil),
}
restClient, err := newRESTClient(cfg, restUATransport, restURL.String(), uploadURL.String(), allowedHosts)
restClient, err := newRESTClient(cfg, restUATransport, restURL.String(), uploadURL.String(), allowedHosts, oauthToken)
if err != nil {
return nil, fmt.Errorf("failed to create REST client: %w", err)
}

// Construct GraphQL client
// We use NewEnterpriseClient unconditionally since we already parsed the API host
gqlHTTPClient := &http.Client{
Transport: &transport.BearerAuthTransport{
Transport: &transport.GraphQLFeaturesTransport{
Transport: &transport.UserAgentTransport{
Transport: http.DefaultTransport,
Agent: stdioUserAgent(cfg, nil),
},
Transport: stdioBearerTransport(cfg, &transport.GraphQLFeaturesTransport{
Transport: &transport.UserAgentTransport{
Transport: http.DefaultTransport,
Agent: stdioUserAgent(cfg, nil),
},
Token: cfg.Token,
TokenProvider: cfg.TokenProvider,
AllowedHosts: allowedHosts,
},
}, allowedHosts, oauthToken),
}

gqlClient := githubv4.NewEnterpriseClient(graphQLURL.String(), gqlHTTPClient)
Expand All @@ -121,7 +149,7 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv
Transport: http.DefaultTransport,
Agent: stdioUserAgent(cfg, nil),
}
rawRESTClient, err := newRESTClient(cfg, rawUATransport, restURL.String(), uploadURL.String(), allowedHosts)
rawRESTClient, err := newRESTClient(cfg, rawUATransport, restURL.String(), uploadURL.String(), allowedHosts, oauthToken)
if err != nil {
return nil, fmt.Errorf("failed to create raw REST client: %w", err)
}
Expand Down Expand Up @@ -154,19 +182,18 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv
// supplied user-agent transport. Authentication uses BearerAuthTransport for
// both static and provider-backed tokens, and allowedHosts scopes the token to
// the configured GitHub hosts so it is never leaked to off-host redirects.
func newRESTClient(cfg github.MCPServerConfig, uaTransport *transport.UserAgentTransport, restURL, uploadURL string, allowedHosts []string) (*gogithub.Client, error) {
func newRESTClient(cfg github.MCPServerConfig, uaTransport *transport.UserAgentTransport, restURL, uploadURL string, allowedHosts []string, oauthToken oauthTokenProvider) (*gogithub.Client, error) {
return gogithub.NewClient(
gogithub.WithHTTPClient(&http.Client{Transport: &transport.BearerAuthTransport{
Transport: uaTransport,
Token: cfg.Token,
TokenProvider: cfg.TokenProvider,
AllowedHosts: allowedHosts,
}}),
gogithub.WithHTTPClient(&http.Client{Transport: stdioBearerTransport(cfg, uaTransport, allowedHosts, oauthToken)}),
gogithub.WithEnterpriseURLs(restURL, uploadURL),
)
}

func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Server, error) {
return newStdioMCPServer(ctx, cfg, nil)
}

func newStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig, oauthToken oauthTokenProvider) (*mcp.Server, error) {
apiHost, err := utils.NewAPIHost(cfg.Host)
if err != nil {
return nil, fmt.Errorf("failed to parse API host: %w", err)
Expand All @@ -177,7 +204,7 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se
return nil, fmt.Errorf("failed to classify API host: %w", err)
}

clients, err := createGitHubClients(cfg, apiHost)
clients, err := createGitHubClients(cfg, apiHost, oauthToken)
if err != nil {
return nil, fmt.Errorf("failed to create GitHub clients: %w", err)
}
Expand Down Expand Up @@ -362,14 +389,14 @@ func RunStdioServer(cfg StdioServerConfig) error {
logger.Debug("skipping scope filtering for non-PAT token")
}

tokenProvider := cfg.TokenProvider
var oauthToken oauthTokenProvider
var toolHandlerMiddleware []inventory.ToolHandlerMiddleware
if cfg.OAuthManager != nil {
tokenProvider = cfg.OAuthManager.AccessToken
oauthToken = cfg.OAuthManager.AccessTokenContext
toolHandlerMiddleware = append(toolHandlerMiddleware, createOAuthToolMiddleware(cfg.OAuthManager, logger))
}

ghServer, err := NewStdioMCPServer(ctx, github.MCPServerConfig{
ghServer, err := newStdioMCPServer(ctx, github.MCPServerConfig{
Version: cfg.Version,
Host: cfg.Host,
Token: cfg.Token,
Expand All @@ -385,9 +412,9 @@ func RunStdioServer(cfg StdioServerConfig) error {
Logger: logger,
RepoAccessTTL: cfg.RepoAccessCacheTTL,
TokenScopes: tokenScopes,
TokenProvider: tokenProvider,
TokenProvider: cfg.TokenProvider,
ToolHandlerMiddleware: toolHandlerMiddleware,
})
}, oauthToken)
if err != nil {
return fmt.Errorf("failed to create MCP server: %w", err)
}
Expand Down
Loading