Como configurar o tmux para que ele inicie com as janelas especificadas abertas?

Você pode escrever um pequeno script de shell que inicie o tmux com os programas necessários. Eu tenho o seguinte em um script de shell que eu chamo dev-tmux. Um ambiente de desenvolvimento:

#!/bin/sh
tmux new-session -d 'vim'
tmux split-window -v 'ipython'
tmux split-window -h
tmux new-window 'mutt'
tmux -2 attach-session -d

Então, toda vez que eu quero lançar meu ambiente de desenvolvimento favorito, eu posso fazer

$ dev-tmux

Eu estava tentando criar uma grade complexa de painéis e tive que lidar com a troca e divisão de painéis repetidas vezes. Aqui estão os meus aprendizados:

tmux new-session \;

Começa com uma nova sessão. Dividi-lo uso horizontal ou vertical split-window -hou -vposteriormente, assim:

tmux new-session \; split-window -v \; split-window -h \;

Cria 3 painéis, assim:

------------
|          |
|----------|
|    |     |
------------

Para executar comandos nesses painéis, basta adicioná-los com o send-keys 'my-command'comando e C-mqual o executa:

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v \; \
  split-window -h \; \
  send-keys 'top' C-m \; 

E a sessão resultante deve ser assim.

------------
|  tail    |
|----------|
|    | top |
------------

Agora, tentei subdividir novamente o painel inferior esquerdo, para voltar a usar last-paneou em janelas mais complexas, com select-pane -t 1onde 1é o número do painel na ordem criada a partir de 0.

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v \; \
  split-window -h \; \
  send-keys 'top' C-m \; \
  select-pane -t 1 \; \
  split-window -v \; \
  send-keys 'weechat' C-m \;

Faz isso. Basicamente, conhecer o caminho de volta split-windowe select-paneé tudo o que você precisa. Também é útil passar com -p 75um tamanho percentual do painel criado split-windowpara ter mais controle sobre o tamanho dos painéis.

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v -p 75 \; \
  split-window -h -p 30 \; \
  send-keys 'top' C-m \; \
  select-pane -t 1 \; \
  split-window -v \; \
  send-keys 'weechat' C-m \;

O que resulta em uma sessão assim

------------------
|      tail      |
|----------------|
|          | top |
|----------|     |
| weechat  |     |
------------------

Espero que ajude os tmuxentusiastas no futuro.

Você pode obter diferentes sessões do seu .tmux.confgosto, assim:

# initialize sessions
bind S source-file ~/.tmux/session1 
bind s source-file ~/.tmux/session2

E formate as sessões conforme necessário:

#session1
new  -s SessionName -n WindowName Command
neww -n foo/bar foo
splitw -v -p 50 -t 0 bar
selectw -t 1 
selectp -t 0

Isso abriria duas janelas, a segunda com o nome foo / bar e seria dividida verticalmente ao meio (50%) com o foo sendo executado acima da barra. O foco estaria na janela 2 (foo / bar), painel superior (foo).

Você pode iniciar sua sessão tmux preferida (nesse caso, sessão1) com PrefixShifts

Use tmuxinator - permite que você tenha várias sessões configuradas, e você pode escolher qual iniciar a qualquer momento. Você pode iniciar comandos em janelas ou painéis específicos e atribuir títulos a janelas. Aqui está um exemplo de uso no desenvolvimento de aplicativos Django .

Arquivo de configuração de amostra:

# ~/.tmuxinator/project_name.yml
# you can make as many tabs as you wish...

project_name: Tmuxinator
project_root: ~/code/rails_project
socket_name: foo # Not needed. Remove to use default socket
rvm: 1.9.2@rails_project
pre: sudo /etc/rc.d/mysqld start
tabs:
  - editor:
      layout: main-vertical
      panes:
        - vim
        - #empty, will just run plain bash
        - top
  - shell: git pull
  - database: rails db
  - server: rails s
  - logs: tail -f logs/development.log
  - console: rails c
  - capistrano:
  - server: ssh me@myhost

Veja o README no link acima para obter uma explicação completa.

dê uma olhada em https://github.com/remiprev/teamocil

você pode especificar sua estrutura usando o YAML

windows:
  - name: sample-window
    splits:
      - cmd: vim
      - cmd:
        - ipython
        width: 50
      - cmd:
        height: 25

:~$ tmux new-session "tmux source-file ~/session1"  

sessão 1

neww
split-window -v 'ipython'  
split-window -h  
new-window 'mutt'  

crie um alias no .bashrc

:~$ echo `alias tmux_s1='tmux new-session "tmux source-file ~/session1"'` >>~/.bashrc  
:~$ . ~/.bashrc  
:~$ tmux_s1  

Primeiro, tive a abordagem do @jasonwryan, mas se você tiver mais de 2 configurações, pode ficar confuso.

Então, eu criei uma função de alias:

tmx () {
    tmux "$2" source-file "$HOME/.tmux/$1.conf";
}

Em ~/.tmux/eu tenho várias sessões para muitos usos. Por exemplo, eu trabalho para empresas diferentes que têm um ambiente de desenvolvimento para outro. Portanto, com a função alias acima, eu posso simplesmente chamar: tmx company1e carregar a configuração necessária.

Atualização: O objetivo de "$ 2" após o tmuxcomando é que você possa passar argumentos adicionais do tmux.

No meu script "get.all", que invoco todas as manhãs para executar vários trabalhos subsequentes "get.XXX" para atualizar o software que eu rastreado. Alguns deles são encerrados automaticamente. Outros exigem mais interação quando o get terminar (como pedir para criar o emacs).

#!/bin/sh
tmux att -t get ||
tmux \
  new -s get -n capp \; \
  send-keys 'get.capp' C-m \; \
  neww -n emacs \; \
  send-keys 'get.emacs' C-m \; \
  neww -n git \; \
  send-keys 'get.git' C-m \; \
  neww -n mini \; \
  send-keys 'get.mini' C-m \; \
  neww -n port \; \
  send-keys 'get.port' C-m \; \
  neww -n rakudo \; \
  send-keys 'get.rakudo' C-m \; \
  neww -n neil \; \
  send-keys 'get.neil && get.neil2 && exit' C-m \; \
  neww -n red \; \
  send-keys 'get.red && exit' C-m \; \
  neww -n cpan \; \
  send-keys 'get.cpan && exit' C-m \; \
  selectw -t emacs

Se você quiser apenas dividir a tela em 2 painéis (digamos na horizontal), execute este comando (não são necessários scripts tmux ou shell):

tmux new-session \; split-window -h \;

Sua tela ficará assim:

[ks@localhost ~]$                      │[ks@localhost ~]$ 
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
[10] 0:ks@localhost:~*                  "localhost.localdomain" 19:51 31-янв-16

E é assim que eu faço:

#!/bin/bash

function has-session {
  tmux has-session -t name_of_my_session 2>/dev/null
}

if has-session ; then
  echo "Session already exists"
else
  cd /path/to/my/project
  tmux new-session -d -s name_of_my_session 'vim'
  tmux split-window -h -p 40 start_web_server
  tmux split-window -v
  tmux attach-session -d -t name_of_my_session
fi

Eu tenho um arquivo para cada um dos meus projetos. Além disso, você pode agrupá-los para ter alguns para trabalhar, alguns para projetos de hobby.

Além disso, você pode movê-lo para a ~/binpasta, adicioná-lo PATHe dar um tmux_my_awesome_projectnome. Então você poderá executá-lo em cada lugar.

Isso funciona para mim. Criando 5 janelas com os nomes dados e selecionando automaticamente a homejanela.

new  -n home
neww -n emacs
neww -n puppet
neww -n haskell
neww -n ruby
selectw -t 1

Tente bro , é um bootstrapper de projeto.

Ele fornece APIs fáceis de interagir tmux.

Parece algo como isto:

#!/bin/sh
# @ project_name/tasks/init.sh
structure project_name
  window editor
    run 'vim'
  window terminal
    run 'echo happy coding ...'
focus editor
connect project_name

Para iniciar um projeto, tudo o que você precisa fazer é executar o seguinte comando -

bro start <project_name>

Confira o screencast abaixo, ele mostra como começar broe usar sua tmuxAPI.

https://user-images.githubusercontent.com/8296449/50532502-2cf3e400-0b6e-11e9-84af-c5f77a04e5cc.gif

O plug - in tmux-continuum salvará automaticamente sua sessão tmux e a carregará na próxima vez que o tmux iniciar, deve ser mais fácil de configurar do que algumas das soluções de script personalizadas aqui.

Recursos:

• economia contínua do ambiente tmux
• início automático do tmux quando o computador / servidor está ligado
• restauração automática quando o tmux é iniciado

Para salvar sua sessão sob demanda, você pode usar o plug- in tmux-ressurrect . O tmux-resurrect também é necessário para executar o tmux-continuum

O tmux-ressurrect salva todos os pequenos detalhes do seu ambiente tmux, para que possa ser completamente restaurado após a reinicialização do sistema (ou quando você desejar). Nenhuma configuração é necessária. Você deve sentir que nunca saiu do tmux.

Existe um plugin tmux para isso.

Confira tmux-ressurrect

Restaure o ambiente tmux após a reinicialização do sistema.

O Tmux é ótimo, exceto quando você precisa reiniciar o computador. Você perde todos os programas em execução, diretórios de trabalho, layouts de painel etc. Existem ferramentas de gerenciamento úteis por aí, mas exigem configuração inicial e atualizações contínuas à medida que seu fluxo de trabalho evolui ou você inicia novos projetos.

O tmux-ressurrect salva todos os pequenos detalhes do seu ambiente tmux, para que possa ser completamente restaurado após a reinicialização do sistema (ou quando você desejar). Nenhuma configuração é necessária. Você deve sentir que nunca saiu do tmux.

Ou tmux-continuum

Recursos:

• economia contínua do ambiente tmux
• início automático do tmux quando o computador / servidor está ligado
• restauração automática quando o tmux é iniciado

Você pode usar os ganchos do tmux para executar comandos quando uma nova sessão é criada. Especificamente, isso é conseguido usando o session-createdgancho.

Por exemplo, para dividir a tela de três maneiras com o htop em execução no canto inferior direito, você pode adicionar a seguinte linha ao seu ~/.tmux.confarquivo:

set-hook -g session-created 'split -h ; split -v top'

A vantagem desse método é que você não precisa executar o tmux de nenhuma maneira especial (por exemplo, shell script ou alias) para obter o resultado desejado. Você também pode combinar isso com o tmux new-session -A -s mysessiondescrito nesta outra resposta , de forma que os comandos hook sejam executados apenas quando você criar a sessão pela primeira vez, e não nos anexos subsequentes.

Esse recurso foi adicionado pelo d15d54c2c em 2016. O primeiro lançamento a incluí-lo é o 2.4.

Você deve especificá-lo no seu arquivo de configuração tmux ( ~/.tmux.conf), por exemplo:

new mocp
neww mutt

new -d
neww
neww

(abre uma sessão com 2 janelas com o mocp iniciado em primeiro e o mutt em segundo e outra sessão desanexada com 3 janelas vazias).

Eu criei esse script . Não precisa de tmuxinator, ruby ​​ou outros. É apenas um script bash, configurável:

Um arquivo chamado config deve conter algo como isto:

combo=()
combo+=('logs' 'cd /var/log; clear; pwd')
combo+=('home' 'cd ~; clear; pwd')

e o código do bash deve ser:

#!/bin/bash

if [ -r config ]; then
    echo ""
    echo "Loading custom file"
    . config
else
    . config.dist
fi

tmux start-server

window=0
windownumber=-1

for i in "${combo[@]}"; do

    if [ $((window%2)) == 0 ]; then
        name=${i}
        ((windownumber++))
    else
        command=${i}
    fi

    if [ ${combo[0]} == "${i}" ]; then
        tmux new-session -d -s StarTmux -n "${name}"
    else
        if [ $((window%2)) == 0 ]; then
            tmux new-window -tStarTmux:$windownumber -n "${name}"
        fi
    fi

    if [ $((window%2)) == 1 ]; then
        tmux send-keys -tStarTmux:$windownumber "${command}" C-m
    fi

    ((window++))
done

tmux select-window -tStarTmux:0
tmux attach-session -d -tStarTmux

Eu apenas tentei usar todas as idéias desta página e não gostei de nenhuma delas. Eu só queria uma solução que iniciasse o tmux com um conjunto específico de janelas quando meu terminal fosse aberto. Eu também queria que fosse idempotente, ou seja, abrir uma nova janela de terminal assume a sessão do tmux da anterior.

As soluções acima costumam abrir várias sessões do tmux e eu quero apenas uma. Primeiro, adicionei isso ao meu ~/.bash_profile:

tmux start-server
if [[ -z "$TMUX" ]]
then
  exec tmux attach -d -t default
fi

então adicionei o seguinte ao meu ~/.tmux.conf:

new -s default -n emacs /usr/local/bin/emacs
neww -n shell /usr/local/bin/bash
neww -n shell /usr/local/bin/bash
selectw -t 1

agora toda vez que inicio um terminal ou inicio o tmux ou o que quer que seja, recolojo a configuração desejada existente (a sessão denominada default) ou crio uma nova sessão com essa configuração.

O tmuxp suporta a configuração de sessão JSON ou YAML e uma API python. Um arquivo de configuração simples do tmuxp para criar uma nova sessão na sintaxe YAML é:

session_name: 2-pane-vertical
windows:
  - window_name: my test window
    panes:
      - pwd
      - pwd

Este script inicia uma sessão com o nome "e" e três janelas

#!/bin/sh 
tmux new-session -s e   -n etc -d 'cd /etc; bash -i'
tmux new-window  -t e:1 -n home   'cd ~; bash -i'
tmux new-window  -t e:2 -n log   'cd /var/log; bash -i'

tmux select-window -t e:1
tmux -2 attach-session -t e