bash: reading from tty in piped script

The read -p calls in both script.sh and pipe.sh read from the current terminal, and since the commands in a pipeline run in parallel, you can make no assumptions about which of them is first to snatch the data entered by the user.

The read -p from one script.sh may put out its prompt, but the string entered by the user may be read by the read -p from pipe.sh and vice-versa.

In a pipeline like a | b, b could be easily made to wait for input from a before proceeding further, but the reverse is not true: since pipes are buffering, a would have to write a lot of data before noticing that b is not reading any of it.

One way out of this is to connect the stdout of b with the stdin of a in a kind of "circular pipeline", and modify a (script.sh) to also wait for input from stdin, just like b (pipe.sh) does.

Because of the shell language's limitations, you should use a named pipe for that. Simple example:

cat > circpipe <<'EOT'; chmod 755 circpipe
fifo=$(mktemp -u)
mkfifo "$fifo" || exit 1
exec 3<>"$fifo" >"$fifo" <"$fifo"
rm "$fifo"
echo trigger
"$1" | "$2"
EOT

cat > pipe-head <<'EOT'; chmod 755 pipe-head
while read next; do
        read -p "HEAD's prompt>> " var </dev/tty || exit
        echo "$var"
done
EOT

cat > pipe-tail <<'EOT'; chmod 755 pipe-tail
while read input; do
        echo >&2 "  TAIL'input: $input"
        read -p "  TAIL's prompt>> " var </dev/tty
        echo >&2 "  TAIL processing <$var>"
        echo next       # trigger the head of the pipeline
done
EOT

./circpipe ./pipe-head ./pipe-tail
HEAD's prompt>> foo
  TAIL'input: foo
  TAIL's prompt>> bar
  TAIL processing <bar>
HEAD's prompt>> baz
  TAIL'input: baz
  TAIL's prompt>> quux
  TAIL processing <quux>
HEAD's prompt>> ^D$

The circpipe script could be made into a more general tool, which would accept regular shell commands, and where its "tail" could also break out of the loop.

Unlike the example above, this will not "kick start" the loop by default; for that, a -command argument should be used. Example use:

./circpipe -echo './pipe-head | stdbuf -oL sed s/e/o/g | ./pipe-tail'
HEAD's prompt>> pee
  TAIL'input: poo
  TAIL's prompt>> lol
  TAIL processing <lol>
HEAD's prompt>>^D

circpipe

#! /bin/sh
# usage: circpipe [-start_command] shell_command
# run 'shell_command' with its stdin connected to its stdout
# via a FIFO
# if 'start_command' is given, run it before `shell_command`
# with its stdout redirected to the same FIFO
[ "$#" -gt 0 ] || exit 0
fifo=$(mktemp -u)
mkfifo "$fifo" || exit 1
exec 3<>"$fifo" >"$fifo" 3<"$fifo"
rm "$fifo"
case $1 in -*)  eval "${1#-}"; shift; esac
IFS='|'; eval "<&3 $* &"
exec >&-
wait