From 8129d38e5764a052194cc9c64eb696253e6d0262 Mon Sep 17 00:00:00 2001 From: Yunus Ardaguney Date: Tue, 10 Nov 2026 15:03:39 +0300 Subject: [PATCH 1/2] fix: fail closed on invalid boolean env settings and support yes/no/on/off When configuring boolean settings via environment variables (such as GITHUB_READ_ONLY or GITHUB_LOCKDOWN_MODE), Viper binds pflag flags which use strconv.ParseBool. Any unrecognised value (e.g. 'yes', 'on', 'tru') causes pflag's Set method to fail silently and Viper defaults to false. This meant GITHUB_READ_ONLY=yes would silently leave read-only mode off, exposing write tools without warning. Introduce parseBoolSetting which accepts common truthy ('1', 't', 'true', 'yes', 'y', 'on', 'enabled') and falsy ('0', 'f', 'false', 'no', 'n', 'off', 'disabled') values, while failing closed with a descriptive error on unrecognised values. Explicit CLI flags preserve standard precedence. Fixes #3747 Co-authored-by: Rafe Walker --- cmd/github-mcp-server/main.go | 107 +++++++++++++++++++++++++---- cmd/github-mcp-server/main_test.go | 87 +++++++++++++++++++++++ 2 files changed, 181 insertions(+), 13 deletions(-) diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go index 04ba68e226..f8b8ac225b 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 := strings.TrimSpace(viper.GetString(key)) + if str == "" { + if flag != nil { + return strconv.ParseBool(flag.DefValue) + } + return false, nil + } + switch strings.ToLower(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..2670cb1018 100644 --- a/cmd/github-mcp-server/main_test.go +++ b/cmd/github-mcp-server/main_test.go @@ -10,6 +10,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 +94,89 @@ func TestSchemaTypeString(t *testing.T) { }) } } + +func TestParseBoolSetting(t *testing.T) { + 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}, + {"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}, + } + + 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"} + for _, v := range invalidValues { + t.Setenv("GITHUB_READ_ONLY", v) + flag := rootCmd.PersistentFlags().Lookup("read-only") + _, err := parseBoolSetting("read-only", flag) + require.Error(t, err) + assert.Contains(t, err.Error(), `invalid boolean value "`+v+`" for GITHUB_READ_ONLY`) + } + }) + + 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) + }) +} From 8019c41d1794362e260eaed61ab391d1afc68bfc Mon Sep 17 00:00:00 2001 From: Yunus Ardaguney Date: Sun, 15 Nov 2026 15:10:46 +0300 Subject: [PATCH 2/2] fix: use parseBoolSetting in list-scopes and reject whitespace-only bool settings - list-scopes now reads read-only through parseBoolSetting, so GITHUB_READ_ONLY=yes lists read-only scopes and invalid values fail. - A whitespace-only value is no longer treated as unset; it goes through the invalid-value branch. - TestParseBoolSetting calls initConfig() so it runs on its own. --- cmd/github-mcp-server/list_scopes.go | 5 ++- cmd/github-mcp-server/list_scopes_test.go | 55 +++++++++++++++++++++++ cmd/github-mcp-server/main.go | 4 +- cmd/github-mcp-server/main_test.go | 21 ++++++--- 4 files changed, 75 insertions(+), 10 deletions(-) create mode 100644 cmd/github-mcp-server/list_scopes_test.go 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 f8b8ac225b..6f7083f8f1 100644 --- a/cmd/github-mcp-server/main.go +++ b/cmd/github-mcp-server/main.go @@ -437,14 +437,14 @@ func parseBoolSetting(key string, flag *pflag.Flag) (bool, error) { } return false, nil } - str := strings.TrimSpace(viper.GetString(key)) + str := viper.GetString(key) if str == "" { if flag != nil { return strconv.ParseBool(flag.DefValue) } return false, nil } - switch strings.ToLower(str) { + 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": diff --git a/cmd/github-mcp-server/main_test.go b/cmd/github-mcp-server/main_test.go index 2670cb1018..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" @@ -96,6 +97,7 @@ func TestSchemaTypeString(t *testing.T) { } func TestParseBoolSetting(t *testing.T) { + initConfig() tests := []struct { envVal string expected bool @@ -114,6 +116,7 @@ func TestParseBoolSetting(t *testing.T) { {"ON", true}, {"enabled", true}, {"ENABLED", true}, + {" yes ", true}, {"0", false}, {"f", false}, {"F", false}, @@ -128,6 +131,7 @@ func TestParseBoolSetting(t *testing.T) { {"OFF", false}, {"disabled", false}, {"DISABLED", false}, + {" no ", false}, } for _, tc := range tests { @@ -149,13 +153,16 @@ func TestParseBoolSetting(t *testing.T) { } t.Run("invalid boolean fails closed with descriptive error", func(t *testing.T) { - invalidValues := []string{"tru", "flase", "invalid", "2", "none"} - for _, v := range invalidValues { - t.Setenv("GITHUB_READ_ONLY", v) - flag := rootCmd.PersistentFlags().Lookup("read-only") - _, err := parseBoolSetting("read-only", flag) - require.Error(t, err) - assert.Contains(t, err.Error(), `invalid boolean value "`+v+`" for GITHUB_READ_ONLY`) + 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)) + } } })