Come impostare tmux in modo che si avvii con le finestre specificate aperte?

È possibile scrivere un piccolo script di shell che avvia tmux con i programmi richiesti. Ho uno script di shell che chiamo dev-tmux. Un ambiente di sviluppo:

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

Quindi ogni volta che voglio lanciare il mio ambiente di sviluppo preferito posso semplicemente farlo

$ dev-tmux

Stavo cercando di creare una griglia complessa di riquadri e ho dovuto occuparmi di cambiare e dividere i riquadri più e più volte. Ecco i miei apprendimenti:

tmux new-session \;

Ti inizia con una nuova sessione. Per dividerlo in orizzontale o verticale utilizzare split-window -ho -vsuccessivamente, in questo modo:

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

Crea 3 riquadri, in questo modo:

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

Per eseguire comandi in quei riquadri, basta aggiungerli con il send-keys 'my-command'comando e C-mche lo esegue:

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 la sessione risultante dovrebbe apparire così.

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

Ora ho provato a suddividere nuovamente il riquadro in basso a sinistra, quindi passare indietro usando last-pane, o in finestre più complesse, con select-pane -t 1dove 1è il numero del riquadro in ordine creato a partire da 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 \;

Fa quello. Fondamentalmente conoscendo la tua strada split-windowed select-paneè tutto ciò di cui hai bisogno. È anche utile passare con -p 75una dimensione percentuale del riquadro creato da split-windowper avere un maggiore controllo sulla dimensione dei riquadri.

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

Il che si traduce in una sessione simile a quella

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

Spero che aiuti gli tmuxappassionati in futuro.

Puoi creare sessioni diverse dalle tue in questo .tmux.confmodo:

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

E quindi formatta le sessioni come richiesto:

#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

Questo aprirebbe 2 finestre, la seconda delle quali si chiamerebbe foo / bar e verrebbe divisa a metà in verticale (50%) con foo che corre sopra la barra. Il focus sarebbe nella finestra 2 (foo / bar), riquadro superiore (foo).

È quindi possibile avviare la sessione tmux preferita (in questo caso, sessione1) con PrefixShifts

Usa tmuxinator : ti consente di configurare più sessioni e puoi scegliere quale avviare in qualsiasi momento. È possibile avviare comandi in particolari finestre o riquadri e assegnare titoli a Windows. Ecco un esempio di utilizzo con lo sviluppo di applicazioni Django .

File di configurazione di esempio:

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

Vedere il file README al link sopra per una spiegazione completa.

dai un'occhiata a https://github.com/remiprev/teamocil

puoi specificare la tua struttura usando YAML

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

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

session1

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

crea un alias in .bashrc

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

Innanzitutto ho avuto l'approccio di @jasonwryan ma se hai più di 2 configurazioni, può diventare confuso.

Quindi ho creato una funzione alias:

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

In ~/.tmux/ho più sessioni per molti usi. Ad esempio, lavoro per diverse aziende che hanno un altro ambiente di sviluppo. Quindi con la funzione alias sopra posso semplicemente chiamare: tmx company1e caricare la configurazione di cui ho bisogno.

Aggiornamento: lo scopo di "$ 2" dopo il tmuxcomando è che sei in grado di passare altri argomenti tmux.

Dal mio script "get.all", che invoco ogni mattina per eseguire una serie di lavori "get.XXX" successivi per aggiornare il software che seguo. Alcuni di loro si stanno abbandonando automaticamente. Altri richiedono più interazione una volta terminato il get (come chiedere di creare 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 vuoi solo dividere lo schermo su 2 riquadri (dire in orizzontale), puoi eseguire questo comando (non sono richiesti script tmux o shell):

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

Lo schermo sarà simile al seguente:

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

Ed è così che lo faccio:

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

Ho un file per ciascuno dei miei progetti. Inoltre puoi raggrupparli per avere un po 'di lavoro, altri per progetti di hobby.

Inoltre puoi spostarlo nella ~/bincartella, aggiungerlo a PATHe dare il tmux_my_awesome_projectnome. Quindi sarai in grado di eseguirlo da ogni luogo.

Questo funziona per me. Creazione di 5 finestre con i nomi indicati e selezione automatica della homefinestra.

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

Prova fratello , è un bootstrapper di progetto.

Fornisce semplici API con cui interagire tmux .

Sembra qualcosa del genere:

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

Per avviare un progetto è sufficiente eseguire il comando seguente:

bro start <project_name>

Dai un'occhiata allo screencast qui sotto, mostra come iniziare broe usare la sua tmuxAPI.

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

Il plug -in tmux-continuum salverà automaticamente la sessione di tmux e la caricherà al successivo avvio di tmux, dovrebbe essere più facile da installare rispetto ad alcune delle soluzioni di script personalizzate qui.

Caratteristiche:

• risparmio continuo dell'ambiente tmux
• tmux automatico si avvia all'accensione del computer / server
• ripristino automatico all'avvio di tmux

Per salvare la sessione su richiesta è possibile utilizzare il plug-in tmux-resurrect . tmux-resurrect è anche richiesto per eseguire tmux-continuum

tmux-resurrect salva tutti i piccoli dettagli dal tuo ambiente tmux in modo che possa essere completamente ripristinato dopo un riavvio del sistema (o quando ne hai voglia). Non è richiesta alcuna configurazione. Dovresti sentirti come se non avessi mai smesso di fumare.

C'è un plugin tmux per questo.

Dai un'occhiata a tmux-resurrect

Ripristina l'ambiente tmux dopo il riavvio del sistema.

Tmux è eccezionale, tranne quando è necessario riavviare il computer. Si perdono tutti i programmi in esecuzione, le directory di lavoro, i layout dei riquadri ecc. Esistono utili strumenti di gestione, ma richiedono una configurazione iniziale e aggiornamenti continui con l'evoluzione del flusso di lavoro o l'avvio di nuovi progetti.

tmux-resurrect salva tutti i piccoli dettagli dal tuo ambiente tmux in modo che possa essere completamente ripristinato dopo un riavvio del sistema (o quando ne hai voglia). Non è richiesta alcuna configurazione. Dovresti sentirti come se non avessi mai smesso di fumare.

O tmux-continuum

Caratteristiche:

• risparmio continuo dell'ambiente tmux
• tmux automatico si avvia all'accensione del computer / server
• ripristino automatico all'avvio di tmux

È possibile utilizzare gli hook di tmux per eseguire comandi quando viene creata una nuova sessione. In particolare, ciò si ottiene utilizzando il session-createdgancio.

Ad esempio, per dividere lo schermo in tre modi con htop in esecuzione in basso a destra è possibile aggiungere la seguente riga al ~/.tmux.conffile:

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

Il vantaggio di questo metodo è che non è necessario eseguire tmux in alcun modo speciale (ad esempio, shell script o alias) per ottenere il risultato desiderato. Puoi anche combinare questo con quello tmux new-session -A -s mysessiondescritto in questa altra risposta in modo tale che i comandi hook vengano eseguiti solo quando crei per la prima volta la sessione e non sugli allegati successivi.

Questa funzione è stata aggiunta da d15d54c2c nel 2016. La prima versione a includerla è la 2.4.

Dovresti specificarlo nel tuo file tmux config ( ~/.tmux.conf), ad esempio:

new mocp
neww mutt

new -d
neww
neww

(apre una sessione con 2 finestre con mocp lanciato nel primo e mutt nel secondo e un'altra sessione staccata con 3 finestre vuote).

Ho creato questo script . Non ha bisogno di contaminanti, rubini o altri. È solo uno script bash, configurabile:

Un file chiamato config dovrebbe contenere qualcosa del genere:

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

e il codice bash dovrebbe essere:

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

Ho appena provato a usare tutte le idee in questa pagina e non mi piaceva nessuna di esse. Volevo solo una soluzione che fosse iniziata con un set specifico di finestre all'apertura del mio terminale. Volevo anche che fosse idempotente, ovvero l'apertura di una nuova finestra del terminale prende il posto della sessione tmux della precedente.

Le soluzioni sopra spesso tendono ad aprire più sessioni di tmux e ne voglio solo una. Innanzitutto, ho aggiunto questo al mio ~/.bash_profile:

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

quindi ho aggiunto quanto segue al mio ~/.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

ora ogni volta che avvio un terminale o avvio tmux o qualsiasi altra cosa, ricollego alla mia configurazione desiderata esistente (la sessione denominata default) o creo una nuova sessione con quella configurazione.

tmuxp supporta la configurazione della sessione JSON o YAML e un'API python. Un semplice file di configurazione di tmuxp per creare una nuova sessione nella sintassi YAML è:

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

Questo script avvia una sessione con il nome "e" e tre finestre

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