refactor: simplify feature flag handling by removing meta feature flags

Author: RossTarrant

internal/ghmcp/server.go

@@ -344,12 +344,9 @@ 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 and meta flags.
+// features are resolved once at startup from --features CLI flag and insiders mode.
 func createFeatureChecker(enabledFeatures []string, insidersMode bool) inventory.FeatureFlagChecker {
-	featureSet := github.ResolveFeatureFlags(
-		enabledFeatures,
-		github.MetaFeatureFlagsForInsiders(insidersMode)...,
-	)
+	featureSet := github.ResolveFeatureFlags(enabledFeatures, insidersMode)
 	return func(_ context.Context, flagName string) (bool, error) {
 		return featureSet[flagName], nil
 	}

pkg/github/feature_flags.go

@@ -11,9 +11,6 @@ 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.
@@ -35,41 +32,25 @@ var InsidersFeatureFlags = []string{
 	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 validated against AllowedFeatureFlags
-//  2. Adding concrete features expanded from enabled meta feature flags
+//  2. Adding features enabled by insiders mode from InsidersFeatureFlags
 //
 // Returns a set (map) for O(1) lookup by the feature checker.
-func ResolveFeatureFlags(enabledFeatures []string, enabledMetaFeatures ...string) map[string]bool {
+func ResolveFeatureFlags(enabledFeatures []string, insidersMode bool) map[string]bool {
 	effective := make(map[string]bool)
 	for _, f := range enabledFeatures {
 		if slices.Contains(AllowedFeatureFlags, f) {
 			effective[f] = true
 		}
 	}
-	for _, metaFeature := range enabledMetaFeatures {
-		for _, f := range MetaFeatureFlags[metaFeature] {
+	if insidersMode {
+		for _, f := range InsidersFeatureFlags {
 			effective[f] = true
 		}
 	}

pkg/github/feature_flags_test.go

@@ -140,7 +140,7 @@ func TestResolveFeatureFlags(t *testing.T) {
 	tests := []struct {
 		name            string
 		enabledFeatures []string
-		metaFeatures    []string
+		insidersMode    bool
 		expectedFlags   []string
 		unexpectedFlags []string
 	}{
@@ -156,15 +156,15 @@ func TestResolveFeatureFlags(t *testing.T) {
 			expectedFlags:   []string{MCPAppsFeatureFlag},
 		},
 		{
-			name:            "insiders meta feature enables insiders flags",
+			name:            "insiders mode enables insiders flags",
 			enabledFeatures: nil,
-			metaFeatures:    []string{MetaFeatureFlagInsiders},
+			insidersMode:    true,
 			expectedFlags:   InsidersFeatureFlags,
 		},
 		{
-			name:            "insiders meta feature enables internal-only flags",
+			name:            "insiders mode enables internal-only flags",
 			enabledFeatures: nil,
-			metaFeatures:    []string{MetaFeatureFlagInsiders},
+			insidersMode:    true,
 			expectedFlags:   []string{FeatureFlagIFCLabels},
 		},
 		{
@@ -187,15 +187,15 @@ func TestResolveFeatureFlags(t *testing.T) {
 		{
 			name:            "explicit plus insiders deduplicates",
 			enabledFeatures: []string{MCPAppsFeatureFlag},
-			metaFeatures:    []string{MetaFeatureFlagInsiders},
+			insidersMode:    true,
 			expectedFlags:   InsidersFeatureFlags,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			result := ResolveFeatureFlags(tt.enabledFeatures, tt.metaFeatures...)
+			result := ResolveFeatureFlags(tt.enabledFeatures, tt.insidersMode)
 			for _, flag := range tt.expectedFlags {
 				assert.True(t, result[flag], "expected flag %q to be enabled", flag)
 			}

pkg/http/server.go

@@ -232,16 +232,15 @@ func initGlobalToolScopeMap(t translations.TranslationHelperFunc) error {
 }
 
 // createHTTPFeatureChecker creates a feature checker that resolves static CLI
-// features plus per-request header features and meta features.
+// features plus per-request header features and insiders mode.
 func createHTTPFeatureChecker(enabledFeatures []string, insidersMode bool) inventory.FeatureFlagChecker {
 	return func(ctx context.Context, flag string) (bool, error) {
 		headerFeatures := ghcontext.GetHeaderFeatures(ctx)
 		features := make([]string, 0, len(enabledFeatures)+len(headerFeatures))
 		features = append(features, enabledFeatures...)
 		features = append(features, headerFeatures...)
 
-		metaFeatures := github.MetaFeatureFlagsForInsiders(insidersMode || ghcontext.IsInsidersMode(ctx))
-		effective := github.ResolveFeatureFlags(features, metaFeatures...)
+		effective := github.ResolveFeatureFlags(features, insidersMode || ghcontext.IsInsidersMode(ctx))
 		return effective[flag], nil
 	}
 }