Notice that shell scripts need (technically) to be released in (nearly) source form.
AFAIK you can write such a program (even some script) which uses GPL programs without being obliged to make your program GPL-ed.
In particular what matters is if the GPL program is tightly coupled to yours (generally not). This would be the case if it is practically meaningless to use that program without your script (which is unusual) .
To be more specific, the doctrine is that a GPL program A is tightly coupled to another program B if it does not make sense to use A outside of B or B without A. In that specific case B should be GPL-licensed too. In other words, coding willingly a GPL wrapper around/for a proprietary program (or vice versa) is considered "cheating" the free software license.
(IIRC, Sun tried such dirty tricks in the 1990s with an optimizing proprietary code generator above some patched GCC compiler, and that made the FSF and other free software enthusiasts angry. I forgot the legal details, and I am sympathetic with the FSF view).
In other words, it is well known that GPL libraries (there are few of them, a good example is readline; many free software libraries are using the LGPL license, different of the GPL license) can only be used from GPL compatible free software. And the doctrine is not that only a technical linking (in the Unix
ld sense) is relevant, but more generally some tight "binding" or "coupling". So you cannot cheat by replacing that linking with a tight and specific RPCJSON protocol (to "mix" a proprietary program with a GPL library called from a serializing GPL-ed program).
However, I use the programs similarly to libraries in other programming languages.
So you are safe in using GPL programs from proprietary code when these GPL-ed programs can be meaningfully used without your code, which is generally the case. You are cheating if you write specifically some easy GPL program (e.g. forking some prior GPL software, or calling some GPL-ed library) to circumvent GPL obligations.
For example, you'll find quite easily many proprietary programs (e.g. IDEs) using git or GCC, because the same unmodified
/usr/bin/git GPL-ed program (or
/usr/bin/g++ ....) can be meaningfully and easily used on the command line, or by other free software programs.
However, if you wrote a small GPL program which gives a specific JSONRPC protocol to call
readline routines from your proprietary program using that protocol, the court (and the FSF, and me) is likely to consider that as an abuse of the GPL license of
readline. You would be safer if you documented properly that protocol (which becomes some "public" or "common" good or knowledge) and wrote a meaningful GPL program using it (hence validating the idea that your protocol and your GPL program using that protocol have sense independently of your proprietary program).
A concrete example of (large, proprietary) shell scripts using GPL programs is provided by installers of proprietary graphics drivers for Linux from NVIDIA (or from ATI in the past). I was so pissed off by such proprietary drivers that I now boycott NVIDIA and use only AMD graphic cards with their free software drivers (even if the performance is slightly lower).
Some of these external programs are also shell scripts, other are native programs.
The fact that an executable file is in ELF format or is some shell (or other) script is irrelevant (also, the programming language used is not relevant). What matters is the (free software) license of the program or software.
But I am not a lawyer. Feel free to ask one, or to ask some free software organization and read more carefully the GPL FAQ and take more time to understand the philosophy of free software.