tmuxp

You can use the tmux API or a plugin like tmuxp[1] to load a pre-configured session (including running arbitrary shell commands and setting layout). Using this you could automatically spawn your ssh connections as nested tmux sessions. Obviously this brings some complications, namely that you need to set different prefix keys (or double press prefix) and any non-prefix hotkeys always get sent to your local session. Personally I just configure remote tmux to have only prefixed keybinds and never make any complicated layouts on remote sessions so that having to press <inner-prefix> + <key> doesn't get annoying. [1]: https://github.com/tmux-python/tmuxp

Using tmux + tmuxp[1] you can load a pre-configured session and execute arbitrary shell commands for the session, window and pane. I use this to set up shells and editors in the correct dirs (and/or hosts), load lang environments, set env vars and source some zsh aliases and functions that I only want per project. The end result is that I can set up my dev environment (shells with different environments, neovim windows, test runner, various linters I don't wannt integrate into nvim) with a single "tmuxp load <project>". edit: That is just my personal killer feature, obviously having a terminal setup that is consistent cross platform and great for stream processing is a given. [1]: https://github.com/tmux-python/tmuxp

Very similar to tmuxinator, but in python: https://github.com/tmux-python/tmuxp I use this one as I found it easier to set up, and a bit more intuitive to script. Also if you use python rather than ruby, it's easier to understand!

I like tmuxp: https://github.com/tmux-python/tmuxp/blob/master/README.rst

I wrote libtmux (https://libtmux.git-pull.com) as a way to control tmux via python objects. In the backend, it's all tmux CLI commands. tmuxp (https://tmuxp.git-pull.com), similar to tmuxinator, uses libtmux under the hood to build workspaces from a yaml/json file: https://github.com/tmux-python/tmuxp/blob/master/tmuxp/works... Despite that, I've found some people prefer just using plain tmux scripting (https://twitter.com/bitprophet/status/561356905843392514). Aside: That's Jeff Forcier, creator of fabric (http://www.fabfile.org/) Through tmux's formats (http://man7.org/linux/man-pages/man1/tmux.1.html#FORMATS), you can about any info you'd like on your workspace. An area I don't know about is -C (control mode). libtmux could technically use it to get live updates rather than inefficiently and possibly needlessly querying session/window/

I have 3 live projects using click. I like it. Caveat: Click's docs were out of date and had open bugs for what feels like years until it finally updated to 7. version 6 was "unstable" https://github.com/pallets/click/issues/503. Hopefully it's over now. Good things: - More concise than standard library argparse - Testing via CliRunner (http://click.palletsprojects.com/en/7.x/testing/), example: https://github.com/tmux-python/tmuxp/blob/v1.5.3/tests/test_... Feel free to study / copy from mine if you like (license MIT): - https://cihai-cli.git-pull.com/: https://github.com/cihai/cihai-cli/blob/v0.5.0/cihai_cli/cli... - https://tmuxp.git-pull.com/: https://github.com/tmux-python/tmuxp/blob/v1.5.3/tmuxp/cli.p... - https://vcspull-git-pull.com/: https://github.com/vcs-python/vcspull/blob/v1.2.0/vcspull/cl...

For me it's tmuxp (https://github.com/tmux-python/tmuxp/blob/master/README.rst). It allows to create scripts for tmux sessions. It easily shaves off about 1 to 2 minutes of my time everyday.

The benefit of tmuxp is pretty clear from its README[1]. It gives this example: session_name: 4-pane-split windows: - window_name: dev window layout: tiled shell_command_before: - cd ~/ # run as a first command in all panes panes: - shell_command: # pane no. 1 - cd /var/log # run multiple commands in this pane - ls -al | grep \.log - echo second pane # pane no. 2 - echo third pane # pane no. 3 - echo forth pane # pane no. 4 The example is very simple (I use tmuxp to heavily configure the session initialization), but it shows how you can have a config file to set a session's name, set the number and names of windows in there, set the layout of panes differently if you want in each wi

Like python? I'm could use a hand. The codebase across all of these projects are solid. CI already wired in, including Sphinx + ReadTheDocs. Help could be QA'ing pull requests, making features, documentation, and so on. Here's an example project: https://tmuxp.git-pull.com - Request: https://github.com/tony/tmuxp/issues/290 Anything else on the sidebar, underneath of "Projects" of https://git-pull.com Of all those, cihai (https://cihai.git-pull.com) doesn't have as much traction, but if you like Chinese/Japanese/Korean, it may be a fit. I'm building it to be a successor to Christoph Burgmer's cjklib (https://pypi.python.org/pypi/cjklib).

This is a bit late, but in the book The Tao of tmux, I delve into how I use Makefile's to create cross-platform file watchers that can trigger unit tests. https://leanpub.com/the-tao-of-tmux/read#file-watching I use Makefile's regularly on open source and personal profiles (e.g. https://github.com/tony/tmuxp/blob/master/Makefile). Feel free to take and use that code, it's available under the BSD license. The creativity comes in when dealing with cross-platform compatibility: Not all file listing commands are implemented the same. ls(1) doesn't work the same across all shell systems, and find on BSD accepts different arguments than GNU's find. So to collect a list of files to watch, we use POSIX find and store it in a Make variable. Then, there's a need to get a cross platform file watcher. This is tricky since file events work differently

I designed tmuxp (https://tmuxp.git-pull.com) to pretty much deliver the CLI version of a workspace using tmux (https://tmux.github.io/). Works cross platform (Linux, BSD, macOS). And it's been doing the trick for years. Prior to building the tmux workspace, it even can call a bootstrap script (https://github.com/tony/tmuxp/blob/master/bootstrap_env.py) to check for and install dependencies. When a tmuxp session file (https://github.com/tony/tmuxp/blob/master/.tmuxp.yaml) is loaded, it automatically can source the user into virtualenvs, launch file watchers, and so on. Saves so much time. Since most software projects involve the same flow (installing packages locally for the project, launching a test runner.) Other things that help keeping it cross platform are using Makefile and commands conforming to POSIX (https://github.com/tony/tmuxp

The declarative nature of having a YAML/JSON config that consistently abstracts out the commands you'd make. It prevents the mistakes and repetition scripting tmux entails. In addition, there's no need to worry about shell scripting portability across systems. I personally use macOS, Linux and BSDs, so I have to take extra time to ensure my scripts work on machines without Bash. For some shortcuts, tips, and tricks on tmux, I have a section in a book I've recently published at https://leanpub.com/the-tao-of-tmux/read#scripting-tmux. It's freely available online. It covers command aliases, pattern matching, targets and formats. > Side note: tmux has an annoying misfeature that panes can't be named nor does their numbering stay stable. It's a bit tricky to programmatically set up a bunch of panes (can't do `tmux split-window -t mysession:my

entr is is what I eventually settled on after years of searching the perfect utility to build/run tests after file changes. After using gulp, grunt, watching_testrunner (which I eventually inherited maintainership of), watchman, watchdog (https://github.com/gorakhargosh/watchdog), sniffer (https://github.com/jeffh/sniffer) entr is cross-platform on OS X, linux and BSD. watching_testrunner has no BSD support watchman is way too big and not domain specific enough to my needs sniffer worked quite well but it required having a scent.py file everywhere entr keeps it all in a neat, unix like package you can pipe files to. I keep some example usage in my book, The Tao of tmux at https://leanpub.com/the-tao-of-tmux/read#leanpub-auto-file-w.... In this section I demonstrate my workflow with entr(1) in a Makefile. The code I use in the example shou

A couple of years ago, I written an intro to tmux (https://tmux.github.io/) inside tmuxp's (https://github.com/tony/tmuxp) documentation called The Tao of tmux (https://tmuxp.readthedocs.io/en/latest/about_tmux.html). I'm in the process of turning it into a feature book. I am aiming for a December 23rd, 2016 release and am plugging away full time. I make it available to read on the web for free at https://leanpub.com/the-tao-of-tmux/read. The GitHub is at https://github.com/git-pull/tao-of-tmux. For pre-ordering: - The Leanpub page (updated on a regular basis) is https://leanpub.com/the-tao-of-tmux. - Amazon Kindle: https://www.amazon.com/gp/product/B01MG342KU - iTunes: https://geo.itunes.apple.com/us/book/the-tao-of-tmux/id1168912720 Also I have a coupon for pre-orders @ $7.99 https://leanpub.com/the-tao-of-tmux/c/oBsI4y3o4quu. So there

A couple of years ago, I written an intro to tmux (https://tmux.github.io/) inside tmuxp's (https://github.com/tony/tmuxp) documentation called The Tao of tmux (https://tmuxp.readthedocs.io/en/latest/about_tmux.html). I'm in the process of turning it into a feature book. I am aiming for a December 23rd, 2016 release and am plugging away full time. I make it available to read on the web for free at https://leanpub.com/the-tao-of-tmux/read. The GitHub is at https://github.com/git-pull/tao-of-tmux. For pre-ordering: - The Leanpub page (updated on a regular basis) is https://leanpub.com/the-tao-of-tmux. - Amazon Kindle: https://www.amazon.com/gp/product/B01MG342KU - iTunes: https://geo.itunes.apple.com/us/book/the-tao-of-tmux/id1168912720 Also I have a coupon for pre-orders @ $7.99 https://leanpub.com/the-tao-of-tmux/c/oBsI4y3o4quu. I've star