path: root/src/twopane.bash

#!/bin/bash
BASH_ARGV0=twopane.bash
echo -n "$0" >/proc/$$/comm
set -e
set -f
set -o pipefail
shopt -s lastpipe

. read_chars.bash

BOT_SIZE=8
BOT_TITLE=input

if [ $# = 0 ]
then
        TOP_CMD="$SHELL -i"
        BOT_CMD=foreground
        #BOT_CMD=start
        #TOP_EXIT=quit
        #TOP_EXIT=prompt
        TOP_EXIT=restart
else
        TOP_CMD=$*
        BOT_CMD=start
        TOP_EXIT=quit
fi
TOP_TITLE="Command: $TOP_CMD"

TWOPANE=$(mktemp -d)
export TWOPANE TOP_CMD BOT_CMD TOP_TITLE BOT_TITLE BOT_SIZE
trap 'rm -r "$TWOPANE"' EXIT
# STY=$(systemd-escape -p "$TWOPANE")
systemd_escape_path()
{
        declare -n path="$1" result="$2"
        result=$(realpath "$path")
        result=${result//-/--}
        result=${result//\//-}
}
systemd_escape_path TWOPANE STY
STY=$0.$$.$STY

save_file()
{
        cat > "$TWOPANE"/"${1:?$0: Error: filename cannot be empty string}"
}

save_screenrc()
{
        save_file screenrc"${1:+.$1}"
}

save_screenrc <<'.'
# Disable keybindings.
unbindall
escape \0\0
# Disable messages.  This is needed for screen -X/-Q to work reasonably.
msgwait 0
msgminwait 0
# Try to disable blocking the terminal on ^S.
# Doesn't seem to work here.
# More is needed.  Xterm?
nonblock on

# Enable mouse focus
defmousetrack on
mousetrack on

caption string '%t'
layout new
split
focus bottom
resize $BOT_SIZE
screen -ln -t "$BOT_TITLE" 0 bash --noprofile --rcfile "$TWOPANE"/bashrc -i
layout save 0
.

check_screen_pane()
{
        screen -p "$pane" -Q info >/dev/null
}

kill_screen_pane()
{
        while check_screen_pane
        do
                screen -p "$pane" -X kill
        done
}

start_screen_pane()
{
        declare -i pane="${1:-1}"
        (( pane > 0 )) || return
        if check_screen_pane "$pane"
        then
                return
        fi
        shift
        if [ $# = 0 ]
        then
                set -f
                set -- ${TOP_CMD:-bash -i}
        fi
        TOP_TITLE="Command: ${*@Q}"
        screen -X focus top
        screen -X screen -ln -t "$TOP_TITLE" 1 "$@"
        start_screen_pane_subprocess "$pane"
}

start_screen_pane_subprocess()
{
        declare -i pane="${1:-1}"
        subproc_command=(
                exec -a top-pane-tty-forward
                        socat
                                UNIX-LISTEN:"$TWOPANE"/socket
                                STDIN,cfmakeraw,opost=1,onlcr=1!!STDOUT
        )
        screen -p "$pane" -X exec .!. bash -c "${subproc_command[*]}"
}

restart_screen_pane()
{
        kill_screen_pane
        start_screen_pane "$@"
}

connect_coproc()
{
        declare -n coproc="$1"
        shift
        declare -n std1="${!coproc}_STDOUT"
        declare -n std0="${!coproc}_STDIN"
        declare -n opid="${!coproc}_PID"

        if [ $# = 0 ]
        then
                set -- "${!coproc}"
        fi
        if ! [ "$opid" ]
        then
                local STDERR
                {
                        coproc "${!coproc}" \
                        {
                                "$@"
                        } 2>&$STDERR {STDERR}>&-
                } {STDERR}>&2 2>/dev/null
                disown
        fi
        # The copied file descriptors (unlike the original coprocess
        # file descriptors, in ${coproc[0]} and ${coproc[1]}) can be
        # passed to external processes (e.g.: socat(1) instances) and
        # used in subshells.
        {
                exec {std0}<&0 {std1}>&1
        } <&${coproc[0]} >&${coproc[1]}
}

disconnect_coproc()
{
        [ $# = 1 ] || return
        declare -n coproc="$1"
        declare -n std0="${!coproc}_STDIN"
        declare -n std1="${!coproc}_STDOUT"
        declare -n  pid="${!coproc}_PID"
        if [ "$std0" -o "$std1" ]
        then
                exec {std0}<&- {std1}>&-
        fi
        if [ "$pid" ]
        then
                kill "$pid" 2>/dev/null
                wait -f "$pid" 2>/dev/null
        fi
        unset coproc std0 std1 pid
}

connect()
{
        connect_coproc TOP_PANE
}

disconnect()
{
        : "${TOP_PANE_STDIN@A} ${TOP_PANE_STDOUT@A} ${TOP_PANE_PID@A} ${TOP_PANE[@]@A}"
        disconnect_coproc TOP_PANE
        : "${ECHOSEND@A} ${ECHOSEND_PID@A}"
        disconnect_sink ECHOSEND
}

sendc()
{
        [ "${TOP_PANE[0]}" ] || connect
        printf '%s' "$*" >&${TOP_PANE[1]}
}

send()
{
        [ "${TOP_PANE[0]}" ] || connect
        printf '%s\n' "$*" >&${TOP_PANE[1]}
}

restart()
{
        start "$@"
}

start()
{
        foreground "$@"
}

check_tty_reader()
{
        [ "$TTY_FORWARD_PID" ] || return
        TTY_FORWARD_JOBSPEC=$(jobs -sl | pid_to_jobspec "$TTY_FORWARD_PID")
        [ "$TTY_FORWARD_JOBSPEC" ]
}

pid_to_jobspec()
{
        while read jspec pid status cmd
        do
                [ "$pid" = "$1" ] || continue
                jspec=${jspec%]*}
                jspec=%${jspec#[}
                echo $jspec
                return
        done
        false
}

tty_forward()
{
        printf '%d\n' "$BASHPID" > "$TWOPANE"/tty_forward.pid
        read-tty
}

kill_tty_forward()
{
        read pid < "$TWOPANE"/tty_forward.pid
        /bin/kill -INT -- -$pid 2>/dev/null
}

TOP_PANE()
{
        (exec -a bottom-pane-tty-forward socat - UNIX-CONNECT:"$TWOPANE"/socket,forever)
        kill_tty_forward
        case "$TOP_EXIT" in
                restart )
                        start_screen_pane 1
                        kill -USR1 $$
                ;;
                quit )
                        kill -INT $$
                        quit
                ;;
                prompt | * )
                        focus bottom
                ;;
        esac
}

sink()
{
        declare -n fd="$1"
        declare -n pid="${!fd}_PID"
        disconnect_sink "$fd"
        exec {fd}> >("${@:2}")
        pid=$!
}

disconnect_sink()
{
        [ "$1" ] || return
        declare -n fd="$1"
        [ "$fd" ] || return
        declare -n pid="${!fd}_PID"
        exec {fd}>&-
        kill $pid 2>/dev/null
        unset fd pid
}

quiet_bg()
{
        local STDERR
        {
                eval "$(printf '%q ' "$@") & 2>&\$STDERR {STDERR}>&-"
        } {STDERR}>&2 2>/dev/null
}

echo_sender()
{
        (exec -a echo_sender socat - fd:${TOP_PANE_STDIN?$0: Internal error}!!-) |
        tee >(write-tty) >&${TOP_PANE_STDOUT?$0: Internal error}
}

background()
{
        start_screen_pane 1 "$@"
        focus bottom

        disconnect_sink ECHOSEND
        connect
        sink ECHOSEND echo_sender
        quiet_bg tty_forward >&$ECHOSEND

        TTY_FORWARD_PID=$!
        printf '%d\n' "$TTY_FORWARD_PID" > "$TWOPANE"/tty_forward.pid
        printf '%s\n' \
                "#!/bin/bash" \
                "kill -TSTP $TTY_FORWARD_PID" \
                "screen -X focus bottom" \
                > "$TWOPANE"/unforward
        chmod +x "$TWOPANE"/unforward
}

foreground()
{
        check_tty_reader || background "$@"
        focus top
        fg %tty_forward >/dev/null 2>&1
        focus bottom
}

twopane()
{
        start "$@"
}

quit()
{
        screen -X quit
}

focus()
{
        screen -X focus "$@"
}

resize()
{
        screen -X resize "$@"
}

SIGUSR1()
{
        i SIGUSR1 "${BASH_COMMAND@A}"
}

our_bashrc_main()
{
        set -m
        set -f
        set -o pipefail
        #trap 'focus bottom; resize 90%; read -p "Exit> "; quit' EXIT
        trap 'SIGUSR1' USR1
        export PS1="$BOT_TITLE\\\$ "
}

save_file bashrc <<.
BASH_ARGV0=twopane
echo -n "\$0" >/proc/\$\$/comm
${TOP_CMD@A}
${BOT_CMD@A}
${TOP_TITLE@A}
${BOT_TITLE@A}

${TOP_EXIT@A}

$(declare -f)
our_bashrc_main

$BOT_CMD
.

main()
{
        screen -c "$TWOPANE"/screenrc -m -S "$STY" -ln
}

main "$@"