refactor: treat insiders as a feature flag bundle

Author: RossTarrant

internal/ghmcp/server.go

@@ -130,7 +130,6 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se
 		cfg.Translator,
 		github.FeatureFlags{
 			LockdownMode: cfg.LockdownMode,
-			InsidersMode: cfg.InsidersMode,
 		},
 		cfg.ContentWindowSize,
 		featureChecker,
@@ -220,7 +219,7 @@ type StdioServerConfig struct {
 	// LockdownMode indicates if we should enable lockdown mode
 	LockdownMode bool
 
-	// InsidersMode indicates if we should enable experimental features
+	// InsidersMode expands to the curated set of feature flags enabled for insiders.
 	InsidersMode bool
 
 	// ExcludeTools is a list of tool names to disable regardless of other settings.
@@ -337,9 +336,12 @@ func RunStdioServer(cfg StdioServerConfig) error {
 
 // createFeatureChecker returns a FeatureFlagChecker that resolves features
 // using the centralized ResolveFeatureFlags function. For the local server,
-// features are resolved once at startup from --features CLI flag + insiders mode.
+// features are resolved once at startup from --features CLI flag and meta flags.
 func createFeatureChecker(enabledFeatures []string, insidersMode bool) inventory.FeatureFlagChecker {
-	featureSet := github.ResolveFeatureFlags(enabledFeatures, insidersMode)
+	featureSet := github.ResolveFeatureFlags(
+		enabledFeatures,
+		github.MetaFeatureFlagsForInsiders(insidersMode)...,
+	)
 	return func(_ context.Context, flagName string) (bool, error) {
 		return featureSet[flagName], nil
 	}
@@ -364,9 +366,6 @@ func addUserAgentsMiddleware(cfg github.MCPServerConfig, restClient *gogithub.Cl
 				message.Params.ClientInfo.Name,
 				message.Params.ClientInfo.Version,
 			)
-			if cfg.InsidersMode {
-				userAgent += " (insiders)"
-			}
 
 			restClient.UserAgent = userAgent
 

pkg/github/context_tools.go

@@ -105,7 +105,7 @@ func GetMe(t translations.TranslationHelperFunc) inventory.ServerTool {
 			}
 
 			result := MarshalledTextResult(minimalUser)
-			if deps.GetFlags(ctx).InsidersMode {
+			if deps.IsFeatureEnabled(ctx, FeatureFlagIFCLabels) {
 				if result.Meta == nil {
 					result.Meta = mcp.Meta{}
 				}

pkg/github/context_tools_test.go

@@ -139,7 +139,7 @@ func Test_GetMe(t *testing.T) {
 	}
 }
 
-func Test_GetMe_IFC_InsidersMode(t *testing.T) {
+func Test_GetMe_IFC_FeatureFlag(t *testing.T) {
 	t.Parallel()
 
 	serverTool := GetMe(translations.NullTranslationHelper)
@@ -153,34 +153,41 @@ func Test_GetMe_IFC_InsidersMode(t *testing.T) {
 		GetUser: mockResponse(t, http.StatusOK, mockUser),
 	})
 
-	t.Run("insiders mode disabled omits ifc label from result meta", func(t *testing.T) {
-		deps := BaseDeps{
-			Client: github.NewClient(mockedHTTPClient),
-			Flags:  FeatureFlags{InsidersMode: false},
-		}
+	depsWithIFCFeature := func(enabled bool) *BaseDeps {
+		return NewBaseDeps(
+			github.NewClient(mockedHTTPClient), nil, nil, nil,
+			translations.NullTranslationHelper,
+			FeatureFlags{},
+			0,
+			func(_ context.Context, flagName string) (bool, error) {
+				return flagName == FeatureFlagIFCLabels && enabled, nil
+			},
+			stubExporters(),
+		)
+	}
+
+	t.Run("feature disabled omits ifc label from result meta", func(t *testing.T) {
+		deps := depsWithIFCFeature(false)
 		handler := serverTool.Handler(deps)
 
 		request := createMCPRequest(map[string]any{})
 		result, err := handler(ContextWithDeps(context.Background(), deps), &request)
 		require.NoError(t, err)
 		require.False(t, result.IsError)
 
-		assert.Nil(t, result.Meta, "result meta should be nil when insiders mode is disabled")
+		assert.Nil(t, result.Meta, "result meta should be nil when IFC labels are disabled")
 	})
 
-	t.Run("insiders mode enabled includes ifc label in result meta", func(t *testing.T) {
-		deps := BaseDeps{
-			Client: github.NewClient(mockedHTTPClient),
-			Flags:  FeatureFlags{InsidersMode: true},
-		}
+	t.Run("feature enabled includes ifc label in result meta", func(t *testing.T) {
+		deps := depsWithIFCFeature(true)
 		handler := serverTool.Handler(deps)
 
 		request := createMCPRequest(map[string]any{})
 		result, err := handler(ContextWithDeps(context.Background(), deps), &request)
 		require.NoError(t, err)
 		require.False(t, result.IsError)
 
-		require.NotNil(t, result.Meta, "result meta should be set when insiders mode is enabled")
+		require.NotNil(t, result.Meta, "result meta should be set when IFC labels are enabled")
 		ifcLabel, ok := result.Meta["ifc"]
 		require.True(t, ok, "result meta should contain ifc key")
 

pkg/github/dependencies.go

@@ -403,7 +403,6 @@ 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/github/feature_flags.go

@@ -1,11 +1,19 @@
 package github
 
+import "slices"
+
 // MCPAppsFeatureFlag is the feature flag name for MCP Apps (interactive UI forms).
 const MCPAppsFeatureFlag = "remote_mcp_ui_apps"
 
 // FeatureFlagCSVOutput is the feature flag name for CSV output on list tools.
 const FeatureFlagCSVOutput = "csv_output"
 
+// FeatureFlagIFCLabels is the feature flag name for IFC security labels in tool results.
+const FeatureFlagIFCLabels = "ifc_labels"
+
+// MetaFeatureFlagInsiders is the meta feature flag name for insiders mode.
+const MetaFeatureFlagInsiders = "insiders"
+
 // AllowedFeatureFlags is the allowlist of feature flags that can be enabled
 // by users via --features CLI flag or X-MCP-Features HTTP header.
 // Only flags in this list are accepted; unknown flags are silently ignored.
@@ -24,37 +32,45 @@ var AllowedFeatureFlags = []string{
 var InsidersFeatureFlags = []string{
 	MCPAppsFeatureFlag,
 	FeatureFlagCSVOutput,
+	FeatureFlagIFCLabels,
+}
+
+// MetaFeatureFlags maps meta feature flags to the concrete feature flags they enable.
+var MetaFeatureFlags = map[string][]string{
+	MetaFeatureFlagInsiders: InsidersFeatureFlags,
 }
 
 // FeatureFlags defines runtime feature toggles that adjust tool behavior.
 type FeatureFlags struct {
 	LockdownMode bool
+
+	// Deprecated: insiders is resolved into concrete feature flags.
 	InsidersMode bool
 }
 
+// MetaFeatureFlagsForInsiders returns the meta feature flags enabled by insiders mode.
+func MetaFeatureFlagsForInsiders(enabled bool) []string {
+	if !enabled {
+		return nil
+	}
+	return []string{MetaFeatureFlagInsiders}
+}
+
 // ResolveFeatureFlags computes the effective set of enabled feature flags by:
-//  1. Taking explicitly enabled features (from CLI flags or HTTP headers)
-//  2. Adding insiders-expanded features when insiders mode is active
-//  3. Validating all features against the AllowedFeatureFlags allowlist
+//  1. Taking explicitly enabled features validated against AllowedFeatureFlags
+//  2. Adding concrete features expanded from enabled meta feature flags
 //
 // Returns a set (map) for O(1) lookup by the feature checker.
-func ResolveFeatureFlags(enabledFeatures []string, insidersMode bool) map[string]bool {
-	allowed := make(map[string]bool, len(AllowedFeatureFlags))
-	for _, f := range AllowedFeatureFlags {
-		allowed[f] = true
-	}
-
+func ResolveFeatureFlags(enabledFeatures []string, enabledMetaFeatures ...string) map[string]bool {
 	effective := make(map[string]bool)
 	for _, f := range enabledFeatures {
-		if allowed[f] {
+		if slices.Contains(AllowedFeatureFlags, f) {
 			effective[f] = true
 		}
 	}
-	if insidersMode {
-		for _, f := range InsidersFeatureFlags {
-			if allowed[f] {
-				effective[f] = true
-			}
+	for _, metaFeature := range enabledMetaFeatures {
+		for _, f := range MetaFeatureFlags[metaFeature] {
+			effective[f] = true
 		}
 	}
 	return effective

pkg/github/feature_flags_test.go

@@ -18,10 +18,14 @@ import (
 // RemoteMCPEnthusiasticGreeting is a dummy test feature flag .
 const RemoteMCPEnthusiasticGreeting = "remote_mcp_enthusiastic_greeting"
 
-// FeatureChecker is an interface for checking if a feature flag is enabled.
-type FeatureChecker interface {
-	// IsFeatureEnabled checks if a feature flag is enabled.
-	IsFeatureEnabled(ctx context.Context, flagName string) bool
+func featureCheckerFor(enabledFlags ...string) func(context.Context, string) (bool, error) {
+	enabled := make(map[string]bool, len(enabledFlags))
+	for _, flag := range enabledFlags {
+		enabled[flag] = true
+	}
+	return func(_ context.Context, flagName string) (bool, error) {
+		return enabled[flagName], nil
+	}
 }
 
 // HelloWorld returns a simple greeting tool that demonstrates feature flag conditional behavior.
@@ -45,9 +49,6 @@ func HelloWorldTool(t translations.TranslationHelperFunc) inventory.ServerTool {
 			if deps.IsFeatureEnabled(ctx, RemoteMCPEnthusiasticGreeting) {
 				greeting += " Welcome to the future of MCP! 🎉"
 			}
-			if deps.GetFlags(ctx).InsidersMode {
-				greeting += " Experimental features are enabled! 🚀"
-			}
 
 			// Build response
 			response := map[string]any{
@@ -89,12 +90,9 @@ func TestHelloWorld_ConditionalBehavior_Featureflag(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			// Create feature checker based on test case
-			checker := func(_ context.Context, flagName string) (bool, error) {
-				if flagName == RemoteMCPEnthusiasticGreeting {
-					return tt.featureFlagEnabled, nil
-				}
-				return false, nil
+			var enabledFlags []string
+			if tt.featureFlagEnabled {
+				enabledFlags = append(enabledFlags, RemoteMCPEnthusiasticGreeting)
 			}
 
 			// Create deps with the checker
@@ -103,7 +101,7 @@ func TestHelloWorld_ConditionalBehavior_Featureflag(t *testing.T) {
 				translations.NullTranslationHelper,
 				FeatureFlags{},
 				0,
-				checker,
+				featureCheckerFor(enabledFlags...),
 				stubExporters(),
 			)
 
@@ -142,54 +140,62 @@ func TestResolveFeatureFlags(t *testing.T) {
 	tests := []struct {
 		name            string
 		enabledFeatures []string
-		insidersMode    bool
+		metaFeatures    []string
 		expectedFlags   []string
 		unexpectedFlags []string
 	}{
 		{
 			name:            "no features, no insiders",
 			enabledFeatures: nil,
-			insidersMode:    false,
 			expectedFlags:   nil,
-			unexpectedFlags: []string{MCPAppsFeatureFlag},
+			unexpectedFlags: []string{MCPAppsFeatureFlag, FeatureFlagIFCLabels},
 		},
 		{
 			name:            "explicit feature enabled",
 			enabledFeatures: []string{MCPAppsFeatureFlag},
-			insidersMode:    false,
 			expectedFlags:   []string{MCPAppsFeatureFlag},
 		},
 		{
-			name:            "insiders mode enables insiders flags",
+			name:            "insiders meta feature enables insiders flags",
 			enabledFeatures: nil,
-			insidersMode:    true,
+			metaFeatures:    []string{MetaFeatureFlagInsiders},
 			expectedFlags:   InsidersFeatureFlags,
 		},
+		{
+			name:            "insiders meta feature enables internal-only flags",
+			enabledFeatures: nil,
+			metaFeatures:    []string{MetaFeatureFlagInsiders},
+			expectedFlags:   []string{FeatureFlagIFCLabels},
+		},
+		{
+			name:            "internal-only flags are not directly enabled",
+			enabledFeatures: []string{FeatureFlagIFCLabels},
+			expectedFlags:   nil,
+			unexpectedFlags: []string{FeatureFlagIFCLabels},
+		},
 		{
 			name:            "unknown flags are filtered out",
 			enabledFeatures: []string{"unknown_flag", "another_unknown"},
-			insidersMode:    false,
 			unexpectedFlags: []string{"unknown_flag", "another_unknown"},
 		},
 		{
 			name:            "mix of known and unknown flags",
 			enabledFeatures: []string{MCPAppsFeatureFlag, "unknown_flag"},
-			insidersMode:    false,
 			expectedFlags:   []string{MCPAppsFeatureFlag},
 			unexpectedFlags: []string{"unknown_flag"},
 		},
 		{
 			name:            "explicit plus insiders deduplicates",
 			enabledFeatures: []string{MCPAppsFeatureFlag},
-			insidersMode:    true,
-			expectedFlags:   []string{MCPAppsFeatureFlag},
+			metaFeatures:    []string{MetaFeatureFlagInsiders},
+			expectedFlags:   InsidersFeatureFlags,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			result := ResolveFeatureFlags(tt.enabledFeatures, tt.insidersMode)
+			result := ResolveFeatureFlags(tt.enabledFeatures, tt.metaFeatures...)
 			for _, flag := range tt.expectedFlags {
 				assert.True(t, result[flag], "expected flag %q to be enabled", flag)
 			}
@@ -199,66 +205,3 @@ func TestResolveFeatureFlags(t *testing.T) {
 		})
 	}
 }
-
-func TestHelloWorld_ConditionalBehavior_Config(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name             string
-		insidersMode     bool
-		expectedGreeting string
-	}{
-		{
-			name:             "Experimental disabled - default greeting",
-			insidersMode:     false,
-			expectedGreeting: "Hello, world!",
-		},
-		{
-			name:             "Experimental enabled - experimental greeting",
-			insidersMode:     true,
-			expectedGreeting: "Hello, world! Experimental features are enabled! 🚀",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			// Create deps with the checker
-			deps := NewBaseDeps(
-				nil, nil, nil, nil,
-				translations.NullTranslationHelper,
-				FeatureFlags{InsidersMode: tt.insidersMode},
-				0,
-				nil,
-				stubExporters(),
-			)
-
-			// Get the tool and its handler
-			tool := HelloWorldTool(translations.NullTranslationHelper)
-			handler := tool.Handler(deps)
-
-			// Call the handler with deps in context
-			ctx := ContextWithDeps(context.Background(), deps)
-			result, err := handler(ctx, &mcp.CallToolRequest{
-				Params: &mcp.CallToolParamsRaw{
-					Arguments: json.RawMessage(`{}`),
-				},
-			})
-			require.NoError(t, err)
-			require.NotNil(t, result)
-			require.Len(t, result.Content, 1)
-
-			// Parse the response - should be TextContent
-			textContent, ok := result.Content[0].(*mcp.TextContent)
-			require.True(t, ok, "expected content to be TextContent")
-
-			var response map[string]any
-			err = json.Unmarshal([]byte(textContent.Text), &response)
-			require.NoError(t, err)
-
-			// Verify the greeting matches expected based on feature flag
-			assert.Equal(t, tt.expectedGreeting, response["greeting"])
-		})
-	}
-}