Also, separately, a tip: when a command-line utility reads from stdin, and a user doesn't know this upfront, and they run it mistakenly interactively from their terminal, then it looks like the command is "hanging" - the user wants "something" to happen but nothing happens.

The idiom to solve this UX pitfall is to inform the user that the command is not interactive when they expect it to be. This information message is only useful when a human user can see it, so there is no need to print it if the command is not run interactively. You can check this with isatty.IsTerminal() (which we already use in other places. For example:

if isatty.IsTerminal(os.Stdin.Fd()) {
   fmt.Fprintln(stderr, "# Reading proto-encoded pieces of data from stdin.\n# Press Ctrl+C or Ctrl+D to terminate.")
}

Recommendations:

1. pull this entire function into a separate funcon runDebugDecodeProto

2. then also pull the scanner/scan logic into a separate function that takes an io.Reader as argument -- this will facilitate testing

3. finally pull the single code decoding logic also into a separate function

So you'd have:

func runDebugDecodeProto(_ *cobra.Command, _ []string) error { 
    return streamMap(os.Stdout, os.Stdin, 
               func (s string) (bool, string, error) { return tryDecodeValue(s, debugDecodeProtoName) })
}

// streamMap applies `fn` to all the scanned fields in `in`, and reports
// the result of `fn` on `out`.
// Errors returned by `fn` are emitted on `out` with a "warning" prefix.
func streamMap(out os.Writer, in os.Reader, fn func(string) (bool, string, error)) error {
  for sc := NewScanner(); sc.Scan(); {
     for _, field := range strings.Fields(sc.Text()) {
         ok, value, err := fn(field, debugDecodeProtoName)
         if err != nil {
               fmt.Fprintln(out, "warning:  %v", err)
         } else if ok {
               fmt.Fprintln(out, value)
         }
     }
  }
}

// tryDecodeValue tries to decode the given string with the given proto name
// reports ok=false if the data was not valid proto-encoded.
func tryDecodeValue(s, protoName string) (ok bool, val string, err error) {
				bytes, err := gohex.DecodeString(s)
				if err != nil {
					b, err := base64.StdEncoding.DecodeString(field)
					if err != nil {
                                                return false, "", nil
					}
					bytes = b
				}
				msg, err := protoreflect.DecodeMessage(protoName, bytes)
				if err != nil {
                                         return false, "", nil
				}
				j, err := protoreflect.MessageToJSON(msg)
				if err != nil {
                                        // Unexpected error: the data was valid protobuf, but does not
                                        // reflect back to JSON. We report the protobuf struct in the
                                       // error message nonetheless.
					return false, "", errors.Wrapf(err, "while JSON-encoding %#v", msg)
				}
				return true, j.String(), nil
}

Then you can have separate unit tests for streamMap and tryDecodeValue.