Como um dos principais resultados no google ao pesquisar por "PROMPT_COMMAND seperator", sinto que a resposta merece mais esforço do que o que foi dado até agora.

NOTA: Na preparação para este post, testei as versões 3.2, 4.4, 5.0 e 5.1 do Bash (via docker ) e revisei o código-fonte para as mesmas versões (via gnu.org )

Vamos começar ...

Manual(ões) do Bash

Bash <= v5.0

O valor da variável PROMPT_COMMAND é examinado imediatamente antes
Bash imprime cada prompt principal. Se PROMPT_COMMAND estiver definido e
tem um valor não nulo, então o valor é executado como se fosse
foi digitado na linha de comando.

O que isto significa?

Isso significa que o bash faz o equivalente geral de:

eval "${PROMPT_COMMAND:-}"

Portanto, qualquer encadeamento/sequenciamento de comandos que funcionaria para isso evalé permitido.

Bash >= v5.1

Bash examina o valor da variável de array PROMPT_COMMAND
imediatamente antes de imprimir cada prompt principal.

Se algum elemento em PROMPT_COMMAND for definido e não nulo, Bash
executa cada valor, em ordem numérica, como se tivesse sido
digitado na linha de comando.
...
Se esta variável estiver definida e for uma matriz, o valor de cada
set elemento é interpretado como um comando para executar
antes de imprimir o prompt principal ($PS1).

Se estiver definido, mas não for uma variável de matriz, seu valor será usado
como um comando para executar em seu lugar.

O que isto significa?

Isso significa que o bash faz o equivalente geral de:

if [[ ${#PROMPT_COMMAND[@]} -gt 1 ]]; then
    for cmd in "${PROMPT_COMMAND[@]}"; do eval "${cmd:-}"; done
else
    eval "${PROMPT_COMMAND:-}"
fi

ou seja, cada elemento do array é eval'd independentemente

O que a comunidade está fazendo

Fazer uma pesquisa "PROMPT_COMMAND"no github mostra que:

• Em geral, a comunidade usa ;como separador
• Algumas ocorrências usam $'\n'como separador

O que eu vi especificamente

Algumas notas anedóticas:

• Usos do Mac OSX ;(consulte /etc/bashrc_Apple_Terminal)
• Bash-PreExec parece usar$'\n'
• Bash-It usa;

Vamos vê-los em ação

Primeiro, vamos obter um novo ambiente Bash v3.2:

docker run -it --rm bash:3.2
bash-3.2$ 

String delimitada por ponto e vírgula

Testar com uma ;string delimitada por - produz:

bash-3.2$ PROMPT_COMMAND='printf 1;printf 2;printf 3;printf ":\n"'
123:
bash-3.2$ 

String delimitada por linha

Testar isso com uma \nstring -delimitada produz:

bash-3.2$ PROMPT_COMMAND=$'printf 1\nprintf 2\nprintf 3\nprintf ":\n"'
123:
bash-3.2$ 

Misture os dois

Podemos misturar os dois separadores? Yuupp! :

bash-3.2$ PROMPT_COMMAND=$'printf 1;printf 2\nprintf 3;printf ":\n"'
123:
bash-3.2$ 

Que tal Arrays?

Para onde estamos indo, precisamos do Bash v5.1

docker run -it --rm bash:5.1
bash-5.1$ 

Matriz Literal

Testar isso com uma matriz literal produz:

bash-5.1$ PROMPT_COMMAND=( "printf 1" "printf 2" "printf 3" "printf ':\n'" )
123:
bash-5.1$ 

USANDO OS TRÊS!

E se você misturar todos eles:

bash-5.1$ PROMPT_COMMAND=( "printf 1" $'printf 2\nprintf 3' 'printf 4;printf ":\n"' )
1234:
bash-5.1$ 

Qual usar?

Se ${PROMP_COMMAND}for um array, você deve anexar/prefixar seu comando ao array.

OBSERVAÇÃO Que você pode anexar um grupo de comandos (ou seja, uma cadeia de comandos sing ;ou $'\n'delimitada por -) como uma única entrada na matriz, se desejar.

Se ${PROMP_COMMAND}não for uma matriz, você provavelmente deve usar ;ao adicionar seus comandos, pois parece um separador mais oficial, mas saiba que os comandos que você adiciona podem ser scripts mais complexos que podem incluir etapas separadas por $'\n'.

Eu tentaria uma função munging?

Claro !

##
# pc_munge munges PROMPT_COMMAND.
# Tries to accommodate when PROMPT_COMMAND is an array (supported in Bash v5.1+).
# If ${#PROMPT_COMMAND[@]} has 2+ elements, then we treat as an array, otherwise
# we defensively treat it as a string.
# By default, uses ';' as separator.
#
# NOTE: Does NOT check if command is already present
#
# Parms:
#  $1 command to add
#  $2 before | after (default: after)
#  $3 separator (default: ';')
#
pc_munge() {
    [[ -n "$1" ]] || return
    local fs="${3:-;}" # null | '' => default
    case "${2:-after}" in
        before)
            [[ ${#PROMPT_COMMAND[@]} -gt 1 ]] && PROMPT_COMMAND=( "$1" "${PROMPT_COMMAND[@]}" ) || PROMPT_COMMAND="${1}${PROMPT_COMMAND:+${fs}$PROMPT_COMMAND}"
            ;;
        *) # after
            [[ ${#PROMPT_COMMAND[@]} -gt 1 ]] && PROMPT_COMMAND+=( "$1" ) || PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND${fs}}${1}"
            ;;
    esac
}

bash $PROMPT_COMMAND(ou cada elemento, se for um array com bash 5.1+, como já observado por @DavidFarrell) é interpretado como código shell, então você escreveria seu conteúdo da mesma forma que escreveria um script de shell. Em um script de shell, os comandos podem ser separados por ;, newline, |, &, &&, ||, etc, cada um com seu próprio significado.

Então você pode ter por exemplo:

PROMPT_COMMAND='
  cmd1 && cmd2 &
  cmd3; cmd4
  for cmd in cmd5 cmd6; do
    "$cmd"
  done
  cmd7 << "EOF"
foo bar
EOF'

etc.

Para anexar um comando a um já definido $PROMPT_COMMANDe garantir que ele seja executado independentemente dos anteriores, você tem a opção de ;e newline , mas ;não funcionaria se $PROMPT_COMMANDestivesse inicialmente vazio ou no caso especial em que termina em um delimitador de documento aqui (como o nosso EOFacima), assim fazendo:

PROMPT_COMMAND+='
  your extra command here'

(ou com versões mais antigas:

PROMPT_COMMAND=$PROMPT_COMMAND'
  your extra command here'

)

é preferível. Ou:

PROMPT_COMMAND='your extra command here
'$PROMPT_COMMAND

para antecipá-lo para que seja executado primeiro.

Com o bash 5.1+, você também pode anexar um elemento de matriz:

PROMPT_COMMAND+=(
  'your extra command here'
)

Ou prefixar:

PROMPT_COMMAND=(
  'your extra command here'
  "${PROMPT_COMMAND[@]}"
)

Isso deixa um problema em potencial: se a opção errexit( -e) estiver habilitada, e qualquer um dos comandos nesses scripts falhar, o processamento para aí¹, então seu comando extra pode acabar não sendo executado. Isso provavelmente deve ser considerado como um caso patológico. Usar errexitem um shell interativo provavelmente é uma má ideia (já é bastante controverso quando usado em scripts).

Para comparação, em zsh, em vez de $PROMPT_COMMAND, você tem funções de gancho que são chamadas em vários pontos, inspiradas (e aprimoradas) por aliases especiais com nomes semelhantes em tcsh. precmd()é a função que você deseja definir para que seja chamada antes de cada prompt. Em zsh, você também pode definir o precmd_functionsarray especial com funções extras a serem chamadas ( errexittambém afeta o processamento lá¹).

^{¹ o mesmo pode acontecer com a nounsetopção ou se um erro de sintaxe ou qualquer tipo de erro fatal for encontrado durante o processamento.}

$ PROMPT_COMMAND é uma lista separada por dois pontos?

Isso é fácil o suficiente para testar:

$ PROMPT_COMMAND='true:true' bash 
bash: true:true: command not found
$ exit

Então, a resposta é “não”.

Mas você pode considerá-lo como uma sequência de comandos separada por ponto e vírgula , como qualquer outra linha de código shell:

$ PROMPT_COMMAND='echo x;echo y' bash 
x
y
$ exit

É isso que a atribuição em sua pergunta tem: um número de comandos, separados por ponto e vírgula, com o valor anterior de PROMPT_COMMANDanexado ao final.

Claro, outra maneira de executar vários comandos de PROMPT_COMMAND, seria criar uma função e chamá-la de lá.

Dito isso, a printfsequência em seu PROMPT_COMMANDparece algo que pode ser melhor colocado no prompt real, por dois motivos. Primeiro, ele não termina em uma nova linha, então pode atrapalhar a ideia do Bash de onde o cursor está, assim como outros comandos que produzem linhas incompletas antes de sair. Em segundo lugar, se você tiver o shell reimprimir o prompt, por meio da conclusão de tabulação, será exibido novamente PS1, mas PROMPT_COMMANDnão será executado novamente.