Same flag name for different cobra commands does not work

[nii236]

I'm not sure if this is expected behaviour or not.

I have a decryptCmd and encryptCmd cobra commands.

They both have flag message.

func init() {
    RootCmd.AddCommand(encryptCmd)
    encryptCmd.Flags().StringP("message", "m", "teststring", "secret unencrypted base64")
    viper.BindPFlags(encryptCmd.Flags())
}

func init() {
    RootCmd.AddCommand(decryptCmd)
    decryptCmd.Flags().StringP("message", "m", "teststring", "base64 encrypted secret")
    viper.BindPFlags(decryptCmd.Flags())
}

Does viper.GetString() work globally across commands or is it command specific? Because when flags have the same name but for different commands then viper can not get the flag value consistently.

[iamsaso]

Any updates on this?

[fermin-silva]

I think this is the cause:

func (v *Viper) BindFlagValue(key string, flag FlagValue) error {
	if flag == nil {
		return fmt.Errorf("flag for %q is nil", key)
	}
	v.pflags[strings.ToLower(key)] = flag
	return nil
}

If the flag was already bound, it simply overwrites it, and it does it silently.
At the very least it should warn that you are overwriting the flag.

In my case I'm doing

cmd1.PersistentFlags().Int(name, defaultValue, usage)
viper.BindPFlag(name, cmd1.PersistentFlags().Lookup(name))

cmd2.PersistentFlags().Int(name, defaultValue, usage)
viper.BindPFlag(name, cmd2.PersistentFlags().Lookup(name))

so only if I call the second cobra command the flag gets parsed. Otherwise I get the default value

[t00f]

Having the same issue here. I have a rootCmd that has multiple subcommands. 3 of these subcommands needs the following parameter

subcommand.Flags().StringSliceP("param", "p", nil, "Allow to pass multiple parameters to the command")
viper.BindPFlag("param", subcommand.Flags().Lookup("param"))

As I have 3 commands using the same flag "param", viper.GetStringSlice("param") is empty.

I tried to use Persistant Flags instead - it would work for me as subcommands does not have subcommands - but without success.

Any idea / workaround ?

[gesquive]

Wrote a really fast example case for this while debugging it myself.

https://gist.github.com/gesquive/c36501fbd84ecab00d3ff2c9502020f9

Kind of crazy that this bug has been around for a year now.

[himanshugpt]

Encountered same issue.

[stefansedich]

Just ran into this myself too thought I was going crazy, ended up using the workaround in mook-as/fissile@ebd1ad3 and everything is happy again.

[chris-rock]

The issue is that init function is executed by go for each command automatically. The following solution allows to us to keep using the global viper, but only register the binds if a command is executed.

var sub1Cmd = &cobra.Command{
   PreRun: func(cmd *cobra.Command, args []string) {
		viper.BindPFlag("message", cmd.Flags().Lookup("message"))
   },
   ...
}

var sub2Cmd = &cobra.Command{
   PreRun: func(cmd *cobra.Command, args []string) {
		viper.BindPFlag("message", cmd.Flags().Lookup("message"))
   },
   ...
}

See https://github.com/spf13/cobra#prerun-and-postrun-hooks for more details.

[prabhatsharma]

This workaround is working for me. Bind the flag again in every subCmd

Run: func(cmd *cobra.Command, args []string) {
		
		// workaround for https://github.com/spf13/viper/issues/233
		viper.BindPFlag("user", cmd.Flags().Lookup("user"))

		user := viper.GetString("user")

[prologic]

I got bitten by this too. The documentation/readme should not encourage bad design by abusing init() functions like this. This doesn't work because you are mutating Viper configuration and binding options to keys in viper's state that are dynamically bound to the sub-command being executed. Doing it in init() seems wrong here.

I don't call doing this in PreRiun() a "work-around" at all; but the correct way to bind viper flags (for lack of any other documented accepted way).

Bind your viper flags in PreRun() or Ruin() -- **NOT** init()`.

[chen-chao]

I think viper is abused in this case. Local flags are accessible in the local command thus they're not necessarily stored in viper(cobra's readme is a little misleading). viper should be used to store config and global or "trans-command" parameters to avoid name conflicts.

[figadore]

Might be misunderstanding how to apply this workaround

var sub1Cmd = &cobra.Command{
   PreRun: func(cmd *cobra.Command, args []string) {
		viper.BindPFlag("message", cmd.Flags().Lookup("message"))
   },
   ...
}

I ran into initialization loop for cmd errors using scaffolded commands and viper.BindPFlags(cmd.Flags()), so I had to define the PreRun function in init

func init() {
	cmd.Flags().BoolP("debug", "d", false, "Whether to enable debugging")
	cmd.PreRun = func(cmd *cobra.Command, args []string) {
		viper.BindPFlags(cmd.Flags())
	}
}

The README says

This means you can bind as early as you want, even in an init() function.

but it doesn't mention this gotcha at all. Does it need an update?

[miparnisari]

Has someone sent a PR that updates the README? I cannot find any

[leakingtapan]

got bitten by this as well. any plan on address the issue or at least some docs for the workaround?

[ZelvaMan]

I just spend few hours trying to find why my program did not work.
If this is indeed intended behavior, there should at least be some warning in documentation.
The documentation suggest that you should define flags with cobra and bind them to the command in one place, but this isnt possible with current behavior.