Detectar se o terminal atual está passando por mosh ou não

Question

Eu estou tentando descobrir uma maneira de detectar se o terminal / conexão atual (e também sob uma sessão do tmux) é através de mosh ou não.

De este tópico , eu Encontrei em qual sessão do pseudo-terminal estou atualmente:

$ tty
/dev/pts/69

Então, eu preciso de algumas informações sobre o processo que gerou este pseudo-terminal, ou é dono deste tty como um filho. Com as informações, talvez eu possa determinar se é de sshd ou mosh . Mas como posso fazer isso?

Outro desafio : Se o shell atual estiver sob o tmux , o tty recuperado pode não corresponder às informações do sshd / mosh-server, já que o tmux também aloca outro pseudo-terminal. Independentemente de como a sessão do tmux foi criada, precisarei distinguir minha conexão atual de SSH ou mosh. Como isso será possível?

Algumas tentativas:

(1) Para o SSH, foi possível encontrar o processo sshd que corresponde ao tty:

$ ps x | grep sshd | grep 'pts\/27'
 5270 ?        S      0:00 sshd: wookayin@pts/27

Então, posso saber que a conexão atual é através do SSH. No entanto, através do mosh, não consegui encontrar nenhuma informação relevante.

(2) Usar variáveis de ambiente como SSH_CLIENT ou SSH_TTY pode não funcionar porque ambos os ssh / mosh definem essas variáveis, e isso está errado em uma sessão do tmux.

    

Answer 1

Eu encontrei uma solução decente para isso e o envolvi como um script simples: is_mosh :

#!/bin/bash

has_ancestor_mosh() {
    pstree -ps $1 | grep mosh-server
}

is_mosh() {
    # argument handling
    for arg in "$@"; do
        case $arg in
          -v|--verbose) local VERBOSE=YES ;;
          *) ;;
        esac
    done

    if [[ -n "$TMUX" ]]; then
        # current shell is under tmux
        local tmux_current_session=$(tmux display-message -p '#S')
        local tmux_client_id=$(tmux list-clients -t "${tmux_current_session}" -F '#{client_pid}')
        # echo $tmux_current_session $tmux_client_id
        local pid="$tmux_client_id"
    else
        local pid="$$"
    fi

    local mosh_found=$(has_ancestor_mosh $pid)   # or empty if not found
    if [[ -z "$mosh_found" ]]; then
        return 1;    # exit code 1: not mosh
    fi

    test -n "$VERBOSE" && echo "mosh"
    return 0;        # exit code 0: is mosh
}


sourced=0
if [ -n "$ZSH_EVAL_CONTEXT" ]; then
  case $ZSH_EVAL_CONTEXT in *:file) sourced=1;; esac
elif [ -n "$BASH_VERSION" ]; then
  [ "$0" != "$BASH_SOURCE" ] && sourced=1
else
  case ${0##*/} in sh|dash) sourced=1;; esac
fi
if [[ $sourced == 0 ]]; then
  is_mosh $@
fi

A idéia é bem simples: (i) encontrar o cliente tmux que está anexado à sessão tmux atual e, em seguida, (ii) procurar seus processos ancestrais para descobrir se existe um processo mosh.

Pode não estar completo, dependendo dos ambientes, mas eu consegui detectar e aplicar com êxito o recurso de cores de 24 bits somente se não estiver sendo executado em mosh (como mosh não suporta cores de 24 bits ). Aqui está uma solução (adicione estas linhas ao seu ~/.vimrc ):

" 24-bit true color: neovim 0.1.5+ / vim 7.4.1799+
" enable ONLY if TERM is set valid and it is NOT under mosh
function! s:is_mosh()
  let output = system("is_mosh -v")
  if v:shell_error
    return 0
  endif
  return !empty(l:output)
endfunction

function s:auto_termguicolors()
  if !(has("termguicolors"))
    return
  endif

  if (&term == 'xterm-256color' || &term == 'nvim') && !s:is_mosh()
    set termguicolors
  else
    set notermguicolors
  endif
endfunction
call s:auto_termguicolors()