wip

Author: kerobbi

internal/ghmcp/server.go

@@ -135,8 +135,8 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se
 		WithReadOnly(cfg.ReadOnly).
 		WithToolsets(cfg.EnabledToolsets).
 		WithTools(github.CleanTools(cfg.EnabledTools)).
-		WithServerInstructions()
-		// WithFeatureChecker(createFeatureChecker(cfg.EnabledFeatures))
+		WithServerInstructions().
+		WithFeatureChecker(featureChecker)
 
 	// Apply token scope filtering if scopes are known (for PAT filtering)
 	if cfg.TokenScopes != nil {

pkg/context/request.go

@@ -65,3 +65,35 @@ func IsLockdownMode(ctx context.Context) bool {
 	}
 	return false
 }
+
+// insidersCtxKey is a context key for insiders mode
+type insidersCtxKey struct{}
+
+// WithInsidersMode adds insiders mode state to the context
+func WithInsidersMode(ctx context.Context, enabled bool) context.Context {
+	return context.WithValue(ctx, insidersCtxKey{}, enabled)
+}
+
+// IsInsidersMode retrieves the insiders mode state from the context
+func IsInsidersMode(ctx context.Context) bool {
+	if enabled, ok := ctx.Value(insidersCtxKey{}).(bool); ok {
+		return enabled
+	}
+	return false
+}
+
+// headerFeaturesCtxKey is a context key for raw header feature flags
+type headerFeaturesCtxKey struct{}
+
+// WithHeaderFeatures stores the raw feature flags from the X-MCP-Features header into context
+func WithHeaderFeatures(ctx context.Context, features []string) context.Context {
+	return context.WithValue(ctx, headerFeaturesCtxKey{}, features)
+}
+
+// GetHeaderFeatures retrieves the raw feature flags from context
+func GetHeaderFeatures(ctx context.Context) []string {
+	if features, ok := ctx.Value(headerFeaturesCtxKey{}).([]string); ok {
+		return features
+	}
+	return nil
+}

pkg/github/dependencies.go

@@ -248,7 +248,6 @@ type RequestDeps struct {
 	lockdownMode      bool
 	RepoAccessOpts    []lockdown.RepoAccessOption
 	T                 translations.TranslationHelperFunc
-	Flags             FeatureFlags
 	ContentWindowSize int
 
 	// Feature flag checker for runtime checks
@@ -380,6 +379,7 @@ func (d *RequestDeps) GetT() translations.TranslationHelperFunc { return d.T }
 func (d *RequestDeps) GetFlags(ctx context.Context) FeatureFlags {
 	return FeatureFlags{
 		LockdownMode: d.lockdownMode && ghcontext.IsLockdownMode(ctx),
+		InsidersMode: ghcontext.IsInsidersMode(ctx),
 	}
 }
 

pkg/http/features.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"slices"
 
+	ghcontext "github.com/github/github-mcp-server/pkg/context"
 	"github.com/github/github-mcp-server/pkg/github"
 	"github.com/github/github-mcp-server/pkg/inventory"
 )
@@ -14,26 +15,20 @@ var KnownFeatureFlags = []string{
 	github.FeatureFlagHoldbackConsolidatedActions,
 }
 
-// ComposeFeatureChecker combines header-based feature flags with a static checker.
-func ComposeFeatureChecker(headerFeatures []string, staticChecker inventory.FeatureFlagChecker) inventory.FeatureFlagChecker {
-	if len(headerFeatures) == 0 && staticChecker == nil {
-		return nil
-	}
-
-	// Only accept header features that are in the known list
-	headerSet := make(map[string]bool, len(headerFeatures))
-	for _, f := range headerFeatures {
-		if slices.Contains(KnownFeatureFlags, f) {
-			headerSet[f] = true
-		}
+// CreateHTTPFeatureChecker creates a feature checker that reads header features from context
+func CreateHTTPFeatureChecker(staticChecker inventory.FeatureFlagChecker) inventory.FeatureFlagChecker {
+	// Pre-compute whitelist as set for O(1) lookup
+	knownSet := make(map[string]bool, len(KnownFeatureFlags))
+	for _, f := range KnownFeatureFlags {
+		knownSet[f] = true
 	}
 
 	return func(ctx context.Context, flag string) (bool, error) {
-		// Header-based: static string matching
-		if headerSet[flag] {
+		// Check whitelist first, then header features
+		if knownSet[flag] && slices.Contains(ghcontext.GetHeaderFeatures(ctx), flag) {
 			return true, nil
 		}
-		// Static checker
+		// Fall back to static checker
 		if staticChecker != nil {
 			return staticChecker(ctx, flag)
 		}

pkg/http/handler.go

@@ -7,7 +7,6 @@ import (
 
 	ghcontext "github.com/github/github-mcp-server/pkg/context"
 	"github.com/github/github-mcp-server/pkg/github"
-	"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/translations"
@@ -31,6 +30,7 @@ type Handler struct {
 type HandlerOptions struct {
 	GitHubMcpServerFactory GitHubMCPServerFactoryFunc
 	InventoryFactory       InventoryFactoryFunc
+	FeatureChecker         inventory.FeatureFlagChecker
 }
 
 type HandlerOption func(*HandlerOptions)
@@ -47,6 +47,12 @@ func WithInventoryFactory(f InventoryFactoryFunc) HandlerOption {
 	}
 }
 
+func WithHandlerFeatureChecker(checker inventory.FeatureFlagChecker) HandlerOption {
+	return func(o *HandlerOptions) {
+		o.FeatureChecker = checker
+	}
+}
+
 func NewHTTPMcpHandler(
 	ctx context.Context,
 	cfg *ServerConfig,
@@ -66,7 +72,7 @@ func NewHTTPMcpHandler(
 
 	inventoryFactory := opts.InventoryFactory
 	if inventoryFactory == nil {
-		inventoryFactory = DefaultInventoryFactory(cfg, t, nil)
+		inventoryFactory = DefaultInventoryFactory(cfg, t, opts.FeatureChecker)
 	}
 
 	return &Handler{
@@ -141,15 +147,12 @@ func DefaultGitHubMCPServerFactory(r *http.Request, deps github.ToolDependencies
 	return github.NewMCPServer(r.Context(), cfg, deps, inventory)
 }
 
-func DefaultInventoryFactory(_ *ServerConfig, t translations.TranslationHelperFunc, staticChecker inventory.FeatureFlagChecker) InventoryFactoryFunc {
+// DefaultInventoryFactory creates the default inventory factory for HTTP mode
+func DefaultInventoryFactory(_ *ServerConfig, t translations.TranslationHelperFunc, featureChecker inventory.FeatureFlagChecker) InventoryFactoryFunc {
 	return func(r *http.Request) (*inventory.Inventory, error) {
-		b := github.NewInventory(t).WithDeprecatedAliases(github.DeprecatedToolAliases)
-
-		// Feature checker composition
-		headerFeatures := headers.ParseCommaSeparated(r.Header.Get(headers.MCPFeaturesHeader))
-		if checker := ComposeFeatureChecker(headerFeatures, staticChecker); checker != nil {
-			b = b.WithFeatureChecker(checker)
-		}
+		b := github.NewInventory(t).
+			WithDeprecatedAliases(github.DeprecatedToolAliases).
+			WithFeatureChecker(featureChecker)
 
 		b = InventoryFiltersForRequest(r, b)
 		b.WithServerInstructions()

pkg/http/headers/headers.go

@@ -34,6 +34,8 @@ const (
 	MCPToolsHeader = "X-MCP-Tools"
 	// MCPLockdownHeader indicates whether lockdown mode is enabled.
 	MCPLockdownHeader = "X-MCP-Lockdown"
+	// MCPInsidersHeader indicates whether insiders mode is enabled for early access features.
+	MCPInsidersHeader = "X-MCP-Insiders"
 	// MCPFeaturesHeader is a comma-separated list of feature flags to enable.
 	MCPFeaturesHeader = "X-MCP-Features"
 )

pkg/http/middleware/request_config.go

@@ -9,27 +9,42 @@ import (
 	"github.com/github/github-mcp-server/pkg/http/headers"
 )
 
-// WithRequestConfig is a middleware that extracts MCP-related headers and sets them in the request context
+// WithRequestConfig is a middleware that extracts MCP-related headers and sets them in the request context.
+// This includes readonly mode, toolsets, tools, lockdown mode, insiders mode, and feature flags.
 func WithRequestConfig(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		ctx := r.Context()
 
+		// Readonly mode
 		if relaxedParseBool(r.Header.Get(headers.MCPReadOnlyHeader)) {
 			ctx = ghcontext.WithReadonly(ctx, true)
 		}
 
+		// Toolsets
 		if toolsets := headers.ParseCommaSeparated(r.Header.Get(headers.MCPToolsetsHeader)); len(toolsets) > 0 {
 			ctx = ghcontext.WithToolsets(ctx, toolsets)
 		}
 
+		// Tools
 		if tools := headers.ParseCommaSeparated(r.Header.Get(headers.MCPToolsHeader)); len(tools) > 0 {
 			ctx = ghcontext.WithTools(ctx, tools)
 		}
 
+		// Lockdown mode
 		if relaxedParseBool(r.Header.Get(headers.MCPLockdownHeader)) {
 			ctx = ghcontext.WithLockdownMode(ctx, true)
 		}
 
+		// Insiders mode
+		if relaxedParseBool(r.Header.Get(headers.MCPInsidersHeader)) {
+			ctx = ghcontext.WithInsidersMode(ctx, true)
+		}
+
+		// Feature flags
+		if features := headers.ParseCommaSeparated(r.Header.Get(headers.MCPFeaturesHeader)); len(features) > 0 {
+			ctx = ghcontext.WithHeaderFeatures(ctx, features)
+		}
+
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
 }

pkg/http/server.go

@@ -83,19 +83,21 @@ func RunHTTPServer(cfg ServerConfig) error {
 		repoAccessOpts = append(repoAccessOpts, lockdown.WithTTL(*cfg.RepoAccessCacheTTL))
 	}
 
+	featureChecker := CreateHTTPFeatureChecker(nil)
+
 	deps := github.NewRequestDeps(
 		apiHost,
 		cfg.Version,
 		cfg.LockdownMode,
 		repoAccessOpts,
 		t,
 		cfg.ContentWindowSize,
-		nil,
+		featureChecker,
 	)
 
 	r := chi.NewRouter()
 
-	handler := NewHTTPMcpHandler(ctx, &cfg, deps, t, logger)
+	handler := NewHTTPMcpHandler(ctx, &cfg, deps, t, logger, WithHandlerFeatureChecker(featureChecker))
 	handler.RegisterRoutes(r)
 
 	addr := fmt.Sprintf(":%d", cfg.Port)