How do I ensure a bash script argument is a specific value?

I suspect you can accomplish what you want in bash and in a way that is much easier for others to read and understand.

$ cat t.bash
#!/usr/bin/bash

croak() { # dying words
        readonly RED=4    # readability trumps efficiency
        readonly NORMAL=9 # encapsulate terminal cruftiness
        tput setb $RED
        echo -n "ERROR:"
        tput setb $NORMAL
        echo " $2"
        exit $1
}

echo -n "What to do (CLI or GUI?): "
read interfaceType

case ${interfaceType,,} in # converted to lowercase
        gui)
                echo "Doing GUI stuff";;
        cli | cmd)
                echo "Doing CLI stuff";;
        cua)
                croak 3 "IBM Common User Access discontinued";;
        "")
                croak 1 "you must enter a choice";;
        *)
                croak 2 "You must choose between GUI or CLI";;
esac

Some reasons why I think this preferable

• Using tput ensures the script is portable to different terminal types
• Putting the error message construction into a function isolates the IO funkiness. (n.b. "separation of concerns")
• Using a case statement makes the multiple choices much clearer, makes the code simpler to read and more compact
• You can easily have two or more names for a choice without complex, hard to follow, if statements
• Doing a conversion to lowercase means you can write the clearer gui rather than [gG][uU][iI] etc
• You can still have a variety of different validation tests (null choice, unknown choice, etc).
• Don't worry about efficiency until the code is to be executed a million times a second.

$ bash --version
GNU bash, version 5.2.21(1)-release (x86_64-pc-linux-gnu)

No need to use the Korn-style [[ ... ]] let alone Bash's =~ in there, you could use the standard case construct which would make your code more legible.

RED=$'\e[31m' RESET=$'\e[m'

die() {
  while [ "$#" -gt 0 ]
    printf>&2 '%s\n' "${RED}ERROR${RESET} $1"
    shift
  done
  exit 1
}


if [ "$#" -gt 0 ]; then
  interfaceType=$1
  case $interfaceType in
    ( [cC][lL][iI] | [gG][uU][iI] ) 
      printf '%s\n' "You chose the $interfaceType interface type!";;
    ( * )
      die 'interface type must be "cli" or "gui"';;
  esac
else
  die "No interface type specified"
fi

That's standard shell syntax. You can shorten it by switching to a shell with builtin case conversion or case insensitive matching, and that has builtin colour support. Zsh would be a better choice than Bash.

autoload colors; colors
die() {
  print -u2 -rC1 -- "$fg[red]ERROR$reset_color $^@"
  exit 1
}
if (( $# )); then
  interfaceType=$1:l
  case $interfaceType in
    ( cli | gui ) print -r "You chose the $interfaceType interface type!";;
    ( * ) die 'interface type must be "cli" or "gui"';;
  esac
else
  die "No interface type specified"
fi

Beware though that depending on the locale, lower case I may be either ı or i. The above would complain when $1 is CLI in a Turkish locale as clı is neither cli nor gui.

For colouring, here, we're using the colors autoloadable function which defines a few variables including the $fg associative array. You could also use prompt expansion with print -P and the %F{colour} directive:

for psvar {print -ru2 -P '%F{red}ERROR%f %v'}

That would have two advantages:

• That supports more colours (as many as your terminal supports) as it uses the terminfo interface to do so, and can also find the closest match via the zsh/nearcolor module on terminals that support fewer.
• When using that %v (short for %1v for the first element of the $psvar array), it gives a visible representation of the string being displayed (for instance, would represent a backspace character as ^H instead of sending it raw to the terminal where it would cause the cursor to move leftward).

$1:l to convert to lower case using the modifier syntax from csh from the late 70s. ${(L)1} using a parameter expansion flag may be more canonical in zsh. bash's equivalent would be ${1,,}. In Korn-like shells (including zsh and bash), you'd use typeset -l interfaceType="$1".

For case insensitive matching, you can use a (#i)(cli|gui) pattern in zsh after the extendedglob option has been enabled (with set -o extendedglob), a ~(i:cli|gui) pattern in ksh93, or enable the nocasematch option in bash (enabled with shopt -s nocasematch).

Note that [ -z "$1" ] tests whether the expansion of $1 is empty. That could be because no argument was passed ($# is 0), or because an empty first argument has been passed (so was specified, only not with one of the right values). To test whether an argument is specified, you should check the value of $# or use things like [ -z "${1+set}" ] or interfaceType=${1?Error message}, not check the length of that argument.