diff --git a/cmd/github-mcp-server/list_scopes.go b/cmd/github-mcp-server/list_scopes.go index 25e6e87b5c..62a0f7c52a 100644 --- a/cmd/github-mcp-server/list_scopes.go +++ b/cmd/github-mcp-server/list_scopes.go @@ -99,7 +99,10 @@ func runListScopes() error { } } - readOnly := viper.GetBool("read-only") + readOnly, err := parseBoolSetting("read-only", rootCmd.PersistentFlags().Lookup("read-only")) + if err != nil { + return err + } outputFormat := viper.GetString("list-scopes-output") // Create translation helper diff --git a/cmd/github-mcp-server/list_scopes_test.go b/cmd/github-mcp-server/list_scopes_test.go new file mode 100644 index 0000000000..f793916a1c --- /dev/null +++ b/cmd/github-mcp-server/list_scopes_test.go @@ -0,0 +1,55 @@ +package main + +import ( + "encoding/json" + "os" + "testing" + + "github.com/spf13/viper" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestRunListScopesReadOnly(t *testing.T) { + initConfig() + for _, value := range []string{"yes", "no", "on", "off", "tru", " "} { + t.Run(value, func(t *testing.T) { + t.Setenv("GITHUB_READ_ONLY", value) + viper.Set("list-scopes-output", "json") + t.Cleanup(func() { viper.Set("list-scopes-output", nil) }) + + output, err := os.CreateTemp(t.TempDir(), "scopes") + require.NoError(t, err) + stdout := os.Stdout + os.Stdout = output + t.Cleanup(func() { + os.Stdout = stdout + assert.NoError(t, output.Close()) + }) + + err = runListScopes() + if value == "tru" || value == " " { + require.ErrorContains(t, err, "GITHUB_READ_ONLY") + info, err := output.Stat() + require.NoError(t, err) + assert.Zero(t, info.Size()) + return + } + require.NoError(t, err) + _, err = output.Seek(0, 0) + require.NoError(t, err) + var result ScopesOutput + require.NoError(t, json.NewDecoder(output).Decode(&result)) + readOnly := value == "yes" || value == "on" + assert.Equal(t, readOnly, result.ReadOnly) + require.NotEmpty(t, result.Tools) + hasWriteTool := false + for _, tool := range result.Tools { + if !tool.ReadOnly { + hasWriteTool = true + } + } + assert.Equal(t, !readOnly, hasWriteTool) + }) + } +} diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go index 04ba68e226..6f7083f8f1 100644 --- a/cmd/github-mcp-server/main.go +++ b/cmd/github-mcp-server/main.go @@ -6,6 +6,7 @@ import ( "fmt" "os" "runtime/debug" + "strconv" "strings" "time" @@ -116,6 +117,28 @@ var ( } ttl := viper.GetDuration("repo-access-cache-ttl") + + readOnly, err := parseBoolSetting("read-only", cmd.Flag("read-only")) + if err != nil { + return err + } + lockdownMode, err := parseBoolSetting("lockdown-mode", cmd.Flag("lockdown-mode")) + if err != nil { + return err + } + insidersMode, err := parseBoolSetting("insiders", cmd.Flag("insiders")) + if err != nil { + return err + } + exportTranslations, err := parseBoolSetting("export-translations", cmd.Flag("export-translations")) + if err != nil { + return err + } + enableCommandLogging, err := parseBoolSetting("enable-command-logging", cmd.Flag("enable-command-logging")) + if err != nil { + return err + } + stdioServerConfig := ghmcp.StdioServerConfig{ Version: serverVersion, Host: viper.GetString("host"), @@ -123,13 +146,13 @@ var ( EnabledToolsets: enabledToolsets, EnabledTools: enabledTools, EnabledFeatures: enabledFeatures, - ReadOnly: viper.GetBool("read-only"), - ExportTranslations: viper.GetBool("export-translations"), - EnableCommandLogging: viper.GetBool("enable-command-logging"), + ReadOnly: readOnly, + ExportTranslations: exportTranslations, + EnableCommandLogging: enableCommandLogging, LogFilePath: viper.GetString("log-file"), ContentWindowSize: viper.GetInt("content-window-size"), - LockdownMode: viper.GetBool("lockdown-mode"), - InsidersMode: viper.GetBool("insiders"), + LockdownMode: lockdownMode, + InsidersMode: insidersMode, ExcludeTools: excludeTools, RepoAccessCacheTTL: &ttl, } @@ -172,7 +195,7 @@ var ( Use: "http", Short: "Start HTTP server", Long: `Start an HTTP server that listens for MCP requests over HTTP.`, - RunE: func(_ *cobra.Command, _ []string) error { + RunE: func(cmd *cobra.Command, _ []string) error { // Parse toolsets (same approach as stdio — see comment there) var enabledToolsets []string if viper.IsSet("toolsets") { @@ -203,6 +226,36 @@ var ( } ttl := viper.GetDuration("repo-access-cache-ttl") + + readOnly, err := parseBoolSetting("read-only", cmd.Flag("read-only")) + if err != nil { + return err + } + lockdownMode, err := parseBoolSetting("lockdown-mode", cmd.Flag("lockdown-mode")) + if err != nil { + return err + } + insidersMode, err := parseBoolSetting("insiders", cmd.Flag("insiders")) + if err != nil { + return err + } + exportTranslations, err := parseBoolSetting("export-translations", cmd.Flag("export-translations")) + if err != nil { + return err + } + enableCommandLogging, err := parseBoolSetting("enable-command-logging", cmd.Flag("enable-command-logging")) + if err != nil { + return err + } + scopeChallenge, err := parseBoolSetting("scope-challenge", cmd.Flag("scope-challenge")) + if err != nil { + return err + } + trustProxyHeaders, err := parseBoolSetting("trust-proxy-headers", cmd.Flag("trust-proxy-headers")) + if err != nil { + return err + } + httpConfig := ghhttp.ServerConfig{ Version: version, Host: viper.GetString("host"), @@ -211,20 +264,20 @@ var ( BaseURL: viper.GetString("base-url"), ResourcePath: viper.GetString("base-path"), AuthorizationServer: viper.GetString("authorization-server"), - ExportTranslations: viper.GetBool("export-translations"), - EnableCommandLogging: viper.GetBool("enable-command-logging"), + ExportTranslations: exportTranslations, + EnableCommandLogging: enableCommandLogging, LogFilePath: viper.GetString("log-file"), ContentWindowSize: viper.GetInt("content-window-size"), - LockdownMode: viper.GetBool("lockdown-mode"), + LockdownMode: lockdownMode, RepoAccessCacheTTL: &ttl, - ScopeChallenge: viper.GetBool("scope-challenge"), - ReadOnly: viper.GetBool("read-only"), + ScopeChallenge: scopeChallenge, + ReadOnly: readOnly, EnabledToolsets: enabledToolsets, EnabledTools: enabledTools, ExcludeTools: excludeTools, EnabledFeatures: enabledFeatures, - InsidersMode: viper.GetBool("insiders"), - TrustProxyHeaders: viper.GetBool("trust-proxy-headers"), + InsidersMode: insidersMode, + TrustProxyHeaders: trustProxyHeaders, MRTRStateKey: os.Getenv(ghhttp.MRTRStateKeyEnv), } @@ -373,3 +426,31 @@ func wordSepNormalizeFunc(_ *pflag.FlagSet, name string) pflag.NormalizedName { } return pflag.NormalizedName(name) } + +func parseBoolSetting(key string, flag *pflag.Flag) (bool, error) { + if flag != nil && flag.Changed { + return strconv.ParseBool(flag.Value.String()) + } + if !viper.IsSet(key) { + if flag != nil { + return strconv.ParseBool(flag.DefValue) + } + return false, nil + } + str := viper.GetString(key) + if str == "" { + if flag != nil { + return strconv.ParseBool(flag.DefValue) + } + return false, nil + } + switch strings.ToLower(strings.TrimSpace(str)) { + case "1", "t", "true", "yes", "y", "on", "enabled": + return true, nil + case "0", "f", "false", "no", "n", "off", "disabled": + return false, nil + default: + envVar := "GITHUB_" + strings.ToUpper(strings.ReplaceAll(key, "-", "_")) + return false, fmt.Errorf("invalid boolean value %q for %s: expected true, false, 1, 0, yes, no, on, off", str, envVar) + } +} diff --git a/cmd/github-mcp-server/main_test.go b/cmd/github-mcp-server/main_test.go index 48d1367acf..b4f390d130 100644 --- a/cmd/github-mcp-server/main_test.go +++ b/cmd/github-mcp-server/main_test.go @@ -1,6 +1,7 @@ package main import ( + "fmt" "os" "path/filepath" "strings" @@ -10,6 +11,7 @@ import ( "github.com/github/github-mcp-server/v2/pkg/scopes" "github.com/google/jsonschema-go/jsonschema" "github.com/modelcontextprotocol/go-sdk/mcp" + "github.com/spf13/pflag" "github.com/spf13/viper" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -93,3 +95,95 @@ func TestSchemaTypeString(t *testing.T) { }) } } + +func TestParseBoolSetting(t *testing.T) { + initConfig() + tests := []struct { + envVal string + expected bool + }{ + {"1", true}, + {"t", true}, + {"T", true}, + {"true", true}, + {"TRUE", true}, + {"True", true}, + {"yes", true}, + {"YES", true}, + {"y", true}, + {"Y", true}, + {"on", true}, + {"ON", true}, + {"enabled", true}, + {"ENABLED", true}, + {" yes ", true}, + {"0", false}, + {"f", false}, + {"F", false}, + {"false", false}, + {"FALSE", false}, + {"False", false}, + {"no", false}, + {"NO", false}, + {"n", false}, + {"N", false}, + {"off", false}, + {"OFF", false}, + {"disabled", false}, + {"DISABLED", false}, + {" no ", false}, + } + + for _, tc := range tests { + t.Run("read-only="+tc.envVal, func(t *testing.T) { + t.Setenv("GITHUB_READ_ONLY", tc.envVal) + flag := rootCmd.PersistentFlags().Lookup("read-only") + got, err := parseBoolSetting("read-only", flag) + require.NoError(t, err) + assert.Equal(t, tc.expected, got) + }) + + t.Run("lockdown-mode="+tc.envVal, func(t *testing.T) { + t.Setenv("GITHUB_LOCKDOWN_MODE", tc.envVal) + flag := rootCmd.PersistentFlags().Lookup("lockdown-mode") + got, err := parseBoolSetting("lockdown-mode", flag) + require.NoError(t, err) + assert.Equal(t, tc.expected, got) + }) + } + + t.Run("invalid boolean fails closed with descriptive error", func(t *testing.T) { + invalidValues := []string{"tru", "flase", "invalid", "2", "none", " ", "\t\n"} + for _, key := range []string{"read-only", "lockdown-mode"} { + envVar := "GITHUB_" + strings.ToUpper(strings.ReplaceAll(key, "-", "_")) + for _, v := range invalidValues { + t.Setenv(envVar, v) + flag := rootCmd.PersistentFlags().Lookup(key) + _, err := parseBoolSetting(key, flag) + require.Error(t, err) + assert.Contains(t, err.Error(), fmt.Sprintf("invalid boolean value %q for %s", v, envVar)) + } + } + }) + + t.Run("empty or unset defaults to flag default value", func(t *testing.T) { + t.Setenv("GITHUB_READ_ONLY", "") + flag := rootCmd.PersistentFlags().Lookup("read-only") + got, err := parseBoolSetting("read-only", flag) + require.NoError(t, err) + assert.False(t, got) + }) + + t.Run("explicit CLI flag takes precedence over env var", func(t *testing.T) { + t.Setenv("GITHUB_READ_ONLY", "false") + flagSet := pflag.NewFlagSet("test", pflag.ContinueOnError) + flagSet.Bool("read-only", false, "read only") + err := flagSet.Parse([]string{"--read-only"}) + require.NoError(t, err) + + flag := flagSet.Lookup("read-only") + got, err := parseBoolSetting("read-only", flag) + require.NoError(t, err) + assert.True(t, got) + }) +}