¿Cómo configurar tmux para que se inicie con ventanas específicas abiertas?

Puede escribir un pequeño script de shell que inicie tmux con los programas necesarios. Tengo lo siguiente en un script de shell que llamo dev-tmux. Un entorno de desarrollo:

#!/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

Así que cada vez que quiero lanzar mi entorno de desarrollo favorito, puedo hacer

$ dev-tmux

Estaba tratando de crear una cuadrícula compleja de paneles y tuve que lidiar con cambiar y dividir paneles una y otra vez. Aquí están mis aprendizajes:

tmux new-session \;

Comienza con una nueva sesión. Para dividirlo en uso horizontal o vertical split-window -ho -vposteriormente, así:

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

Crea 3 paneles, así:

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

Para ejecutar comandos en esos paneles, simplemente agréguelos con el send-keys 'my-command'comando y el C-mque lo ejecuta:

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

Y la sesión resultante debería verse así.

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

Ahora traté de subdividir nuevamente el panel inferior izquierdo, por lo que volví a usar usando last-pane, o en ventanas más complejas, con select-pane -t 1dónde 1está el número del panel en orden creado 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 \;

Hace eso. Básicamente, conocer su camino split-windowy select-panees todo lo que necesita. También es útil pasar con -p 75un tamaño porcentual del panel creado split-windowpara tener más control sobre el tamaño de los paneles.

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 \;

Lo que resulta en una sesión así

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

Espero que ayude a los tmuxentusiastas en el futuro.

Puede obtener diferentes sesiones de su .tmux.confgusto, así:

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

Y luego formatee las sesiones según lo requiera:

#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

Esto abriría 2 ventanas, la segunda de las cuales se llamaría foo / bar y se dividiría verticalmente por la mitad (50%) con foo corriendo por encima de la barra. El foco estaría en la ventana 2 (foo / bar), panel superior (foo).

Luego puede iniciar su sesión tmux preferida (en este caso, session1) con PrefixShifts

Use tmuxinator : le permite tener múltiples sesiones configuradas y puede elegir cuál iniciar en cualquier momento. Puede ejecutar comandos en ventanas o paneles particulares y asignar títulos a las ventanas. Aquí hay un ejemplo de uso con el desarrollo de aplicaciones Django .

Archivo de configuración de muestra:

# ~/.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

Consulte el archivo README en el enlace anterior para obtener una explicación completa.

echar un vistazo @ https://github.com/remiprev/teamocil

puedes especificar tu estructura usando YAML

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

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

Sesión 1

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

crear un alias en .bashrc

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

Primero tuve el enfoque de @jasonwryan pero si tienes más de 2 configuraciones, puede ser confuso.

Entonces creé una función de alias:

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

En ~/.tmux/tengo varias sesiones para muchos usos. Por ejemplo, trabajo para diferentes compañías que tienen un entorno de desarrollo mutuo. Entonces, con la función de alias anterior, simplemente puedo llamar: tmx company1y cargar la configuración que necesito.

Actualización: El propósito de "$ 2" después del tmuxcomando es que puede pasar argumentos tmux adicionales.

Desde mi script "get.all", que invoco cada mañana para ejecutar un montón de trabajos posteriores "get.XXX" para actualizar el software que sigo. Algunos de ellos son auto-dejar de fumar. Otros requieren más interacción una vez que get ha finalizado (como pedir construir 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

Si solo desea dividir la pantalla en 2 paneles (digamos horizontalmente), puede ejecutar este comando (no se requieren tmux ni scripts de shell):

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

Su pantalla se verá así:

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

Y así es como lo hago:

#!/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

Tengo un archivo para cada uno de mi proyecto. También puedes agruparlos para tener algunos para trabajar y otros para proyectos de pasatiempo.

También puede moverlo a la ~/bincarpeta, agregarlo PATHy asignarle un tmux_my_awesome_projectnombre. Entonces podrás ejecutarlo desde cada lugar.

Esto funciona para mi. Creación de 5 ventanas con los nombres de pila y selección automática a la homeventana.

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

Prueba hermano , es un programa de arranque.

Proporciona apis fáciles para interactuar tmux.

Se parece a esto:

#!/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 un proyecto, todo lo que hay que hacer es ejecutar el siguiente comando:

bro start <project_name>

Vea el screencast a continuación, muestra cómo comenzar broy usar su tmuxAPI.

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

El complemento tmux-continuum guardará automáticamente su sesión de tmux y la cargará la próxima vez que se inicie tmux, debería ser más fácil de configurar que algunas de las soluciones de script personalizadas aquí.

caracteristicas:

• ahorro continuo de entorno tmux
• inicio automático de tmux cuando la computadora / servidor está encendido
• restauración automática cuando se inicia tmux

Para guardar su sesión a pedido, puede usar el complemento tmux-resurrect . tmux-resurrect también es necesario para ejecutar tmux-continuum

tmux-resurrect guarda todos los pequeños detalles de su entorno tmux para que pueda restaurarse por completo después de reiniciar el sistema (o cuando lo desee). No se requiere configuración. Debería sentir que nunca abandonó tmux.

Hay un complemento tmux para esto.

Echa un vistazo a tmux-resurrect

Restaurar el entorno tmux después de reiniciar el sistema.

Tmux es genial, excepto cuando tienes que reiniciar la computadora. Pierde todos los programas en ejecución, directorios de trabajo, diseños de paneles, etc. Existen herramientas de administración útiles, pero requieren una configuración inicial y actualizaciones continuas a medida que su flujo de trabajo evoluciona o comienza nuevos proyectos.

tmux-resurrect guarda todos los pequeños detalles de su entorno tmux para que pueda restaurarse por completo después de reiniciar el sistema (o cuando lo desee). No se requiere configuración. Debería sentir que nunca abandonó tmux.

O tmux-continuum

caracteristicas:

• ahorro continuo de entorno tmux
• inicio automático de tmux cuando la computadora / servidor está encendido
• restauración automática cuando se inicia tmux

Puede usar tmux hooks para ejecutar comandos cuando se crea una nueva sesión. Específicamente, esto se logra usando el session-createdgancho.

Por ejemplo, para dividir la pantalla de tres maneras con htop ejecutándose en la esquina inferior derecha, puede agregar la siguiente línea a su ~/.tmux.confarchivo:

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

La ventaja de este método es que no tiene que ejecutar tmux de ninguna manera especial (es decir, script de alias o alias) para obtener el resultado deseado. También puede combinar esto con lo tmux new-session -A -s mysessiondescrito en esta otra respuesta, de modo que los comandos de enlace solo se ejecutan cuando crea la sesión por primera vez y no en archivos adjuntos posteriores.

D15d54c2c agregó esta característica en 2016. La primera versión que la incluye es la 2.4.

Debe especificarlo en su archivo de configuración de tmux ( ~/.tmux.conf), por ejemplo:

new mocp
neww mutt

new -d
neww
neww

(abre una sesión con 2 ventanas con mocp lanzado en primer lugar y mutt en segundo, y otra sesión separada con 3 ventanas vacías).

He creado este script . No necesita tmuxinator, ruby ​​u otros. Es solo un script bash, configurable:

Un archivo llamado config debería contener algo como esto:

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

y el código bash debería 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

Intenté usar todas las ideas de esta página y no me gustaron. Solo quería una solución que comenzara tmux con un conjunto específico de ventanas cuando se abrió mi terminal. También quería que fuera idempotente, es decir, abrir una nueva ventana de terminal toma el control de la sesión tmux de la anterior.

Las soluciones anteriores a menudo tienden a abrir múltiples sesiones tmux y solo quiero una. Primero, agregué esto a mi ~/.bash_profile:

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

luego agregué lo siguiente a mi ~/.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

ahora, cada vez que inicio un terminal o inicio tmux o lo que sea, vuelvo a conectar mi configuración deseada actual (la sesión nombrada default) o creo una nueva sesión con esa configuración.

tmuxp admite la configuración de sesión JSON o YAML y una API de Python. Un archivo de configuración simple de tmuxp para crear una nueva sesión en sintaxis YAML es:

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

Este script inicia una sesión con el nombre "e" y tres ventanas

#!/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