merge in changes

Author: mattdholloway

docs/server-configuration.md

@@ -394,7 +394,7 @@ Lockdown mode ensures the server only surfaces content in public repositories fr
 Insiders Mode unlocks experimental features. We created this mode to have a way to roll out experimental features and collect feedback. So if you are using Insiders, please don't hesitate to share your feedback with us! Features in Insiders Mode may change, evolve, or be removed based on user feedback.
 
 > [!NOTE]
-> Insiders mode also enables the `remote_mcp_ui_apps` feature flag for backward compatibility. See [MCP Apps](#mcp-apps) below.
+> Insiders mode enables a curated set of feature flags, including `remote_mcp_ui_apps`. See [MCP Apps](#mcp-apps) below.
 
 <table>
 <tr><th>Remote Server</th><th>Local Server</th></tr>

internal/ghmcp/server.go

@@ -115,10 +115,15 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se
 		return nil, fmt.Errorf("failed to create GitHub clients: %w", err)
 	}
 
-	// Create feature checker — insiders mode transitionally enables remote_mcp_ui_apps
+	// Create feature checker — insiders mode expands InsidersFeatureFlags
 	enabledFeatures := cfg.EnabledFeatures
-	if cfg.InsidersMode && !slices.Contains(enabledFeatures, github.MCPAppsFeatureFlag) {
-		enabledFeatures = append(slices.Clone(enabledFeatures), github.MCPAppsFeatureFlag)
+	if cfg.InsidersMode {
+		enabledFeatures = slices.Clone(enabledFeatures)
+		for _, flag := range github.InsidersFeatureFlags {
+			if !slices.Contains(enabledFeatures, flag) {
+				enabledFeatures = append(enabledFeatures, flag)
+			}
+		}
 	}
 	featureChecker := createFeatureChecker(enabledFeatures)
 	mcpAppsEnabled := slices.Contains(enabledFeatures, github.MCPAppsFeatureFlag)
@@ -151,7 +156,6 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se
 		WithExcludeTools(cfg.ExcludeTools).
 		WithServerInstructions().
 		WithFeatureChecker(featureChecker).
-		WithInsidersMode(cfg.InsidersMode).
 		WithMCPApps(mcpAppsEnabled)
 
 	// Apply token scope filtering if scopes are known (for PAT filtering)

pkg/github/feature_flags.go

@@ -1,11 +1,16 @@
 package github
 
-// MCPAppsFeatureFlag is the feature flag name that enables MCP Apps
-// (interactive UI forms) for supported tools. When enabled, tools like
-// get_me, issue_write, and create_pull_request can render rich UI via
-// the MCP Apps extension instead of plain text responses.
+// MCPAppsFeatureFlag is the feature flag name for MCP Apps (interactive UI forms).
 const MCPAppsFeatureFlag = "remote_mcp_ui_apps"
 
+// InsidersFeatureFlags is the list of feature flags that insiders mode enables.
+// When insiders mode is active, all flags in this list are treated as enabled.
+// This is the single source of truth for what "insiders" means in terms of
+// feature flag expansion.
+var InsidersFeatureFlags = []string{
+	MCPAppsFeatureFlag,
+}
+
 // FeatureFlags defines runtime feature toggles that adjust tool behavior.
 type FeatureFlags struct {
 	LockdownMode bool

pkg/http/handler.go

@@ -262,15 +262,10 @@ func InventoryFiltersForRequest(r *http.Request, builder *inventory.Builder) *in
 		builder = builder.WithReadOnly(true)
 	}
 
-	insiders := ghcontext.IsInsidersMode(ctx)
-	if insiders {
-		builder = builder.WithInsidersMode(true)
-	}
-
 	// Enable MCP Apps if the feature flag is present in the request headers
-	// or if insiders mode is active (transitional: insiders implies remote_mcp_ui_apps).
+	// or if insiders mode is active (insiders expands InsidersFeatureFlags).
 	headerFeatures := ghcontext.GetHeaderFeatures(ctx)
-	mcpApps := slices.Contains(headerFeatures, github.MCPAppsFeatureFlag) || insiders
+	mcpApps := slices.Contains(headerFeatures, github.MCPAppsFeatureFlag) || ghcontext.IsInsidersMode(ctx)
 	if mcpApps {
 		builder = builder.WithMCPApps(true)
 	}

pkg/http/server.go

@@ -215,20 +215,26 @@ func initGlobalToolScopeMap(t translations.TranslationHelperFunc) error {
 
 // createHTTPFeatureChecker creates a feature checker that reads header features from context
 // and validates them against the knownFeatureFlags whitelist.
-// It also handles transitional behavior where insiders mode implies remote_mcp_ui_apps.
+// When insiders mode is active, InsidersFeatureFlags are also treated as enabled.
 func createHTTPFeatureChecker() 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
 	}
 
+	// Pre-compute insiders flags as set for O(1) lookup
+	insidersSet := make(map[string]bool, len(github.InsidersFeatureFlags))
+	for _, f := range github.InsidersFeatureFlags {
+		insidersSet[f] = true
+	}
+
 	return func(ctx context.Context, flag string) (bool, error) {
 		if knownSet[flag] && slices.Contains(ghcontext.GetHeaderFeatures(ctx), flag) {
 			return true, nil
 		}
-		// Transitional: insiders mode implies remote_mcp_ui_apps feature flag
-		if flag == github.MCPAppsFeatureFlag && ghcontext.IsInsidersMode(ctx) {
+		// Insiders mode enables all InsidersFeatureFlags
+		if insidersSet[flag] && ghcontext.IsInsidersMode(ctx) {
 			return true, nil
 		}
 		return false, nil

pkg/inventory/builder.go

@@ -48,7 +48,6 @@ type Builder struct {
 	featureChecker       FeatureFlagChecker
 	filters              []ToolFilter // filters to apply to all tools
 	generateInstructions bool
-	insidersMode         bool
 	mcpApps              bool
 }
 
@@ -155,15 +154,6 @@ func (b *Builder) WithExcludeTools(toolNames []string) *Builder {
 	return b
 }
 
-// WithInsidersMode enables or disables insiders mode features.
-// When insiders mode is disabled (default), tools marked InsidersOnly are removed
-// and insiders-only Meta keys are stripped.
-// Returns self for chaining.
-func (b *Builder) WithInsidersMode(enabled bool) *Builder {
-	b.insidersMode = enabled
-	return b
-}
-
 // WithMCPApps enables or disables MCP Apps UI features.
 // When disabled (default), the "ui" Meta key is stripped from tools
 // so clients won't attempt to load UI resources.
@@ -214,11 +204,7 @@ func cleanTools(tools []string) []string {
 // (i.e., they don't exist in the tool set and are not deprecated aliases).
 // This ensures invalid tool configurations fail fast at build time.
 func (b *Builder) Build() (*Inventory, error) {
-	// When insiders mode is disabled, strip insiders-only features from tools
 	tools := b.tools
-	if !b.insidersMode {
-		tools = stripInsidersFeatures(b.tools)
-	}
 
 	// When MCP Apps is disabled, strip UI metadata from tools
 	if !b.mcpApps {
@@ -390,32 +376,6 @@ func (b *Builder) processToolsets() (map[ToolsetID]bool, []string, []ToolsetID,
 	return enabledToolsets, unrecognized, allToolsetIDs, validIDs, defaultToolsetIDList, descriptions
 }
 
-// insidersOnlyMetaKeys lists the Meta keys that are only available in insiders mode.
-// Add new experimental feature keys here to have them automatically stripped
-// when insiders mode is disabled.
-// Note: "ui" (MCP Apps) is now controlled by the remote_mcp_ui_apps feature flag via
-// WithMCPApps and mcpAppsMetaKeys, not by insiders mode.
-var insidersOnlyMetaKeys = []string{}
-
-// stripInsidersFeatures removes insiders-only features from tools.
-// This includes removing tools marked with InsidersOnly and stripping
-// Meta keys listed in insidersOnlyMetaKeys from remaining tools.
-func stripInsidersFeatures(tools []ServerTool) []ServerTool {
-	result := make([]ServerTool, 0, len(tools))
-	for _, tool := range tools {
-		// Skip tools marked as insiders-only
-		if tool.InsidersOnly {
-			continue
-		}
-		if stripped := stripMetaKeys(tool, insidersOnlyMetaKeys); stripped != nil {
-			result = append(result, *stripped)
-		} else {
-			result = append(result, tool)
-		}
-	}
-	return result
-}
-
 // mcpAppsMetaKeys lists the Meta keys controlled by the remote_mcp_ui_apps feature flag.
 var mcpAppsMetaKeys = []string{
 	"ui", // MCP Apps UI metadata

pkg/inventory/registry_test.go

@@ -1853,13 +1853,13 @@ func mockToolWithMeta(name string, toolsetID string, meta map[string]any) Server
 	)
 }
 
-func TestWithInsidersMode_DisabledStripsUIMetadata(t *testing.T) {
+func TestWithMCPApps_DisabledStripsUIMetadata(t *testing.T) {
 	toolWithUI := mockToolWithMeta("tool_with_ui", "toolset1", map[string]any{
 		"ui":          map[string]any{"html": "<div>hello</div>"},
 		"description": "kept",
 	})
 
-	// Default: insiders mode is disabled - UI meta should be stripped
+	// Default: MCP Apps is disabled - UI meta should be stripped
 	reg := mustBuild(t, NewBuilder().SetTools([]ServerTool{toolWithUI}).WithToolsets([]string{"all"}))
 	available := reg.AvailableTools(context.Background())
 
@@ -1899,40 +1899,6 @@ func TestWithMCPApps_EnabledPreservesUIMetadata(t *testing.T) {
 	}
 }
 
-func TestWithInsidersMode_EnabledPreservesInsidersOnlyTools(t *testing.T) {
-	normalTool := mockTool("normal", "toolset1", true)
-	insidersTool := mockTool("insiders_only", "toolset1", true)
-	insidersTool.InsidersOnly = true
-
-	// With insiders mode enabled, both tools should be available
-	reg := mustBuild(t, NewBuilder().
-		SetTools([]ServerTool{normalTool, insidersTool}).
-		WithToolsets([]string{"all"}).
-		WithInsidersMode(true))
-	available := reg.AvailableTools(context.Background())
-
-	require.Len(t, available, 2)
-	names := []string{available[0].Tool.Name, available[1].Tool.Name}
-	require.Contains(t, names, "normal")
-	require.Contains(t, names, "insiders_only")
-}
-
-func TestWithInsidersMode_DisabledRemovesInsidersOnlyTools(t *testing.T) {
-	normalTool := mockTool("normal", "toolset1", true)
-	insidersTool := mockTool("insiders_only", "toolset1", true)
-	insidersTool.InsidersOnly = true
-
-	// With insiders mode disabled, insiders-only tool should be removed
-	reg := mustBuild(t, NewBuilder().
-		SetTools([]ServerTool{normalTool, insidersTool}).
-		WithToolsets([]string{"all"}).
-		WithInsidersMode(false))
-	available := reg.AvailableTools(context.Background())
-
-	require.Len(t, available, 1)
-	require.Equal(t, "normal", available[0].Tool.Name)
-}
-
 func TestWithMCPApps_ToolsWithoutUIMetaUnaffected(t *testing.T) {
 	toolNoUI := mockToolWithMeta("tool_no_ui", "toolset1", map[string]any{
 		"description": "kept",
@@ -1991,25 +1957,6 @@ func TestWithMCPApps_UIOnlyMetaBecomesNil(t *testing.T) {
 	}
 }
 
-func TestWithMCPApps_EnabledPreservesUIMeta(t *testing.T) {
-	// Tool with ui metadata - should be preserved when MCP Apps is enabled
-	toolWithUI := mockToolWithMeta("tool_with_ui", "toolset1", map[string]any{
-		"ui":          map[string]any{"html": "<div>hello</div>"},
-		"description": "kept",
-	})
-
-	reg := mustBuild(t, NewBuilder().
-		SetTools([]ServerTool{toolWithUI}).
-		WithToolsets([]string{"all"}).
-		WithMCPApps(true))
-	available := reg.AvailableTools(context.Background())
-
-	require.Len(t, available, 1)
-	require.NotNil(t, available[0].Tool.Meta, "Meta should be preserved with MCP Apps enabled")
-	require.NotNil(t, available[0].Tool.Meta["ui"], "ui key should be preserved with MCP Apps enabled")
-	require.Equal(t, "kept", available[0].Tool.Meta["description"])
-}
-
 func TestStripMetaKeys(t *testing.T) {
 	tests := []struct {
 		name         string
@@ -2104,23 +2051,6 @@ func TestStripMCPAppsMetadata(t *testing.T) {
 	require.Nil(t, result[2].Tool.Meta)
 }
 
-func TestStripInsidersFeatures_RemovesInsidersOnlyTools(t *testing.T) {
-	// Create tools: one normal, one insiders-only, one normal
-	normalTool1 := mockTool("normal1", "toolset1", true)
-	insidersTool := mockTool("insiders_only", "toolset1", true)
-	insidersTool.InsidersOnly = true
-	normalTool2 := mockTool("normal2", "toolset1", true)
-
-	tools := []ServerTool{normalTool1, insidersTool, normalTool2}
-
-	result := stripInsidersFeatures(tools)
-
-	// Should only have 2 tools (insiders-only tool filtered out)
-	require.Len(t, result, 2)
-	require.Equal(t, "normal1", result[0].Tool.Name)
-	require.Equal(t, "normal2", result[1].Tool.Name)
-}
-
 func TestStripMetaKeys_MultipleKeys(t *testing.T) {
 	// This test verifies the mechanism works for multiple keys
 	keys := []string{"ui", "experimental_feature", "beta"}

pkg/inventory/server_tool.go

@@ -82,10 +82,6 @@ type ServerTool struct {
 	// This includes the required scopes plus any higher-level scopes that provide
 	// the necessary permissions due to scope hierarchy.
 	AcceptedScopes []string
-
-	// InsidersOnly marks this tool as only available when insiders mode is enabled.
-	// When insiders mode is disabled, tools with this flag set are completely omitted.
-	InsidersOnly bool
 }
 
 // IsReadOnly returns true if this tool is marked as read-only via annotations.