v4.0.0

Adds support for saving and restoring pane titles.

.gitattributes

@@ -0,0 +1,5 @@
+# Force text files to have unix eols, so Windows/Cygwin does not break them
+*.* eol=lf
+
+# Except for images because then on checkout the files have been altered.
+*.png binary

.gitignore

@@ -0,0 +1,3 @@
+run_tests
+tests/run_tests_in_isolation
+tests/helpers/helpers.sh

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/tmux-test"]
+	path = lib/tmux-test
+	url = https://github.com/tmux-plugins/tmux-test.git

.travis.yml

@@ -0,0 +1,19 @@
+# generic packages and tmux
+before_install:
+  - sudo apt-get update
+  - sudo apt-get install -y git-core expect
+  - sudo apt-get install -y python-software-properties software-properties-common
+  - sudo apt-get install -y libevent-dev libncurses-dev
+  - git clone https://github.com/tmux/tmux.git
+  - cd tmux
+  - git checkout 2.5
+  - sh autogen.sh
+  - ./configure && make && sudo make install
+
+install:
+  - git fetch --unshallow --recurse-submodules || git fetch --recurse-submodules
+  # manual `git clone` required for testing `tmux-test` plugin itself
+  - git clone https://github.com/tmux-plugins/tmux-test lib/tmux-test; true
+  - lib/tmux-test/setup
+
+script: ./tests/run_tests_in_isolation

CHANGELOG.md

@@ -2,6 +2,66 @@
 
 ### master
 
+### v4.0.0, 2022-04-10
+- Proper handling of `automatic-rename` window option.
+- save and restore tmux pane title (breaking change: you have to re-save to be
+  able to properly restore!)
+
+### v3.0.0, 2021-08-30
+- save and restore tmux pane contents (@laomaiweng)
+- update tmux-test to solve issue with recursing git submodules in that project
+- set options quietly in `resurrect.tmux` script
+- improve pane contents restoration: `cat <file>` is no longer shown in pane
+  content history
+- refactoring: drop dependency on `paste` command
+- bugfix for pane contents restoration
+- expand tilde char `~` if used with `@resurrect-dir`
+- do not save empty trailing lines when pane content is saved
+- do not save pane contents if pane is empty (only for 'save pane contents'
+  feature)
+- "save pane contents" feature saves files to a separate directory
+- archive and compress pane contents file
+- make archive & compress pane contents process more portable
+- `mutt` added to the list of automatically restored programs
+- added guide for migrating from tmuxinator
+- fixed a bug for restoring commands on tmux 2.5 (and probably tmux 2.4)
+- do not create another resurrect file if there are no changes (credit @vburdo)
+- allow using '$HOSTNAME' in @resurrect-dir
+- add zsh history saving and restoring
+- delete resurrect files older than 30 days, but keep at least 5 files
+- add save and restore hooks
+- always use `-ao` flags for `ps` command to detect commands
+- Deprecate restoring shell history feature.
+- `view` added to the list of automatically restored programs
+- Enable vim session strategy to work with custom session files,
+  e.g. `vim -S Session1.vim`.
+- Enable restoring command arguments for inline strategies with `*` character.
+- Kill session "0" if it wasn't restored.
+- Add `@resurrect-delete-backup-after` option to specify how many days of
+  backups to keep - default is 30.
+
+### v2.4.0, 2015-02-23
+- add "tmux-test"
+- add test for "resurrect save" feature
+- add test for "resurrect restore" feature
+- make the tests work and pass on travis
+- add travis badge to the readme
+
+### v2.3.0, 2015-02-12
+- Improve fetching proper window_layout for zoomed windows. In order to fetch
+  proper value, window has to get unzoomed. This is now done faster so that
+  "unzoom,fetch value,zoom" cycle is almost unnoticable to the user.
+
+### v2.2.0, 2015-02-12
+- bugfix: zoomed windows related regression
+- export save and restore script paths so that 'tmux-resurrect-save' plugin can
+  use them
+- enable "quiet" saving (used by 'tmux-resurrect-save' plugin)
+
+### v2.1.0, 2015-02-12
+- if restore is started when there's only **1 pane in the whole tmux server**,
+  assume the users wants the "full restore" and overrwrite that pane.
+
 ### v2.0.0, 2015-02-10
 - add link to the wiki page for "first pane/window issue" to the README as well
   as other tweaks

README.md

@@ -1,6 +1,8 @@
 # Tmux Resurrect
 
-Restore `tmux` environment after a system restart.
+[![Build Status](https://travis-ci.org/tmux-plugins/tmux-resurrect.svg?branch=master)](https://travis-ci.org/tmux-plugins/tmux-resurrect)
+
+Restore `tmux` environment after system restart.
 
 Tmux is great, except when you have to restart the computer. You lose all the
 running programs, working directories, pane layouts etc.
@@ -12,7 +14,11 @@ projects.
 can be completely restored after a system restart (or when you feel like it).
 No configuration is required. You should feel like you never quit tmux.
 
-It even (optionally) [restores vim and neovim sessions](#restoring-vim-and-neovim-sessions)!
+It even (optionally)
+[restores vim and neovim sessions](docs/restoring_vim_and_neovim_sessions.md)!
+
+Automatic restoring and continuous saving of tmux env is also possible with
+[tmux-continuum](https://github.com/tmux-plugins/tmux-continuum) plugin.
 
 ### Screencast
 
@@ -23,11 +29,6 @@ It even (optionally) [restores vim and neovim sessions](#restoring-vim-and-neovi
 - `prefix + Ctrl-s` - save
 - `prefix + Ctrl-r` - restore
 
-For custom key bindings, add to `.tmux.conf`:
-
-    set -g @resurrect-save 'S'
-    set -g @resurrect-restore 'R'
-
 ### About
 
 This plugin goes to great lengths to save and restore all the details from your
@@ -42,33 +43,29 @@ This plugin goes to great lengths to save and restore all the details from your
 - active pane for each window
 - "grouped sessions" (useful feature when using tmux with multiple monitors)
 - programs running within a pane! More details in the
-  [configuration section](#configuration).
-- restoring vim/neovim sessions (optional). More details in
-  [restoring vim and neovim sessions](#restoring-vim-and-neovim-sessions).
-- restoring bash history (optional, \*experimental*). More details in
-  [restoring bash history](#restoring-bash-history-experimental).
+  [restoring programs doc](docs/restoring_programs.md).
+
+Optional:
+
+- [restoring vim and neovim sessions](docs/restoring_vim_and_neovim_sessions.md)
+- [restoring pane contents](docs/restoring_pane_contents.md)
+- [restoring a previously saved environment](docs/restoring_previously_saved_environment.md)
 
 Requirements / dependencies: `tmux 1.9` or higher, `bash`.
 
+Tested and working on Linux, OSX and Cygwin.
+
 `tmux-resurrect` is idempotent! It will not try to restore panes or windows that
-already exist.
-
-### FAQ
-
-> I have a problem: first pane/window is not restoring!
-
-Check out
-[this wiki page](https://github.com/tmux-plugins/tmux-resurrect/wiki/Help:-issues-with-the-first-window)
-for the explanation and problem solution.
+already exist.<br/>
+The single exception to this is when tmux is started with only 1 pane in order
+to restore previous tmux env. Only in this case will this single pane be
+overwritten.
 
 ### Installation with [Tmux Plugin Manager](https://github.com/tmux-plugins/tpm) (recommended)
 
 Add plugin to the list of TPM plugins in `.tmux.conf`:
 
-    set -g @tpm_plugins '           \
-      tmux-plugins/tpm              \
-      tmux-plugins/tmux-resurrect   \
-    '
+    set -g @plugin 'tmux-plugins/tmux-resurrect'
 
 Hit `prefix + I` to fetch the plugin and source it. You should now be able to
 use the plugin.
@@ -83,78 +80,33 @@ Add this line to the bottom of `.tmux.conf`:
 
     run-shell ~/clone/path/resurrect.tmux
 
-Reload TMUX environment:
-
-    # type this in terminal
-    $ tmux source-file ~/.tmux.conf
-
+Reload TMUX environment with: `$ tmux source-file ~/.tmux.conf`.
 You should now be able to use the plugin.
 
-### Configuration
+### Docs
 
-Configuration is not required, but it enables extra features.
+- [Guide for migrating from tmuxinator](docs/migrating_from_tmuxinator.md)
 
-Only a conservative list of programs is restored by default:<br/>
-`vi vim nvim emacs man less more tail top htop irssi`.
+**Configuration**
 
-- Restore additional programs with the setting in `.tmux.conf`:
+- [Changing the default key bindings](docs/custom_key_bindings.md).
+- [Setting up hooks on save & restore](docs/hooks.md).
+- Only a conservative list of programs is restored by default:<br/>
+  `vi vim nvim emacs man less more tail top htop irssi weechat mutt`.<br/>
+  [Restoring programs doc](docs/restoring_programs.md) explains how to restore
+  additional programs.
+- [Change a directory](docs/save_dir.md) where `tmux-resurrect` saves tmux
+  environment.
 
-        set -g @resurrect-processes 'ssh psql mysql sqlite3'
+**Optional features**
 
-- Programs with arguments should be double quoted:
+- [Restoring vim and neovim sessions](docs/restoring_vim_and_neovim_sessions.md)
+  is nice if you're a vim/neovim user.
+- [Restoring pane contents](docs/restoring_pane_contents.md) feature.
 
-        set -g @resurrect-processes 'some_program "git log"'
+**Experimental features (also optional)**
 
-- Start with tilde to restore a program whose process contains target name:
-
-        set -g @resurrect-processes 'irb pry "~rails server" "~rails console"'
-
-- Use `->` to specify a command to be used when restoring a program (useful if
-  the default restore command fails ):
-
-        set -g @resurrect-processes 'some_program "grunt->grunt development"'
-
-- Don't restore any programs:
-
-        set -g @resurrect-processes 'false'
-
-- Restore **all** programs (be careful with this!):
-
-        set -g @resurrect-processes ':all:'
-
-#### Restoring vim and neovim sessions
-
-- save vim/neovim sessions. I recommend
-  [tpope/vim-obsession](https://github.com/tpope/vim-obsession) (as almost every
-  plugin, it works for both vim and neovim).
-- in `.tmux.conf`:
-
-        # for vim
-        set -g @resurrect-strategy-vim 'session'
-        # for neovim
-        set -g @resurrect-strategy-nvim 'session'
-
-`tmux-resurrect` will now restore vim and neovim sessions if `Sessions.vim` file
-is present.
-
-#### Resurrect save dir
-
-By default Tmux environment is saved to a file in `~/.tmux/resurrect` dir.
-Change this with:
-
-    set -g @resurrect-dir '/some/path'
-
-#### Restoring bash history (experimental)
-
-In `.tmux.conf`:
-
-    set -g @resurrect-save-bash-history 'on'
-
-Bash `history` for individual panes will now be saved and restored. Due to
-technical limitations, this only works for panes which have no program running in
-foreground when saving. `tmux-resurrect` will send history write command
-to each such pane. To prevent these commands from being added to history themselves,
-add `HISTCONTROL=ignoreboth` to your `.bashrc` (this is set by default in Ubuntu).
+- [restoring shell history](docs/restoring_shell_history.md)
 
 ### Other goodies
 
@@ -164,6 +116,8 @@ add `HISTCONTROL=ignoreboth` to your `.bashrc` (this is set by default in Ubuntu
   highlighted text to system clipboard
 - [tmux-open](https://github.com/tmux-plugins/tmux-open) - a plugin for quickly
   opening highlighted file or a url
+- [tmux-continuum](https://github.com/tmux-plugins/tmux-continuum) - automatic
+  restoring and continuous saving of tmux env
 
 ### Reporting bugs and contributing
 
@@ -175,12 +129,5 @@ Both contributing and bug reports are welcome. Please check out
 [Mislav Marohnić](https://github.com/mislav) - the idea for the plugin came from his
 [tmux-session script](https://github.com/mislav/dotfiles/blob/2036b5e03fb430bbcbc340689d63328abaa28876/bin/tmux-session).
 
-### Other
-
-Here's another script that tries to solve the same problem:
-[link](http://brainscraps.wikia.com/wiki/Resurrecting_tmux_Sessions_After_Reboot).
-It even has the same name, even though I discovered it only after publishing
-`v1.0` of this plugin.
-
 ### License
 [MIT](LICENSE.md)

docs/custom_key_bindings.md

@@ -0,0 +1,11 @@
+# Custom key bindings
+
+The default key bindings are:
+
+- `prefix + Ctrl-s` - save
+- `prefix + Ctrl-r` - restore
+
+To change these, add to `.tmux.conf`:
+
+    set -g @resurrect-save 'S'
+    set -g @resurrect-restore 'R'

docs/hooks.md

@@ -0,0 +1,39 @@
+# Save & Restore Hooks
+
+Hooks allow to set custom commands that will be executed during session save
+and restore. Most hooks are called with zero arguments, unless explicitly
+stated otherwise.
+
+Currently the following hooks are supported:
+
+- `@resurrect-hook-post-save-layout`
+
+  Called after all sessions, panes and windows have been saved.
+
+  Passed single argument of the state file.
+
+- `@resurrect-hook-post-save-all`
+
+  Called at end of save process right before the spinner is turned off.
+
+- `@resurrect-hook-pre-restore-all`
+
+  Called before any tmux state is altered.
+
+- `@resurrect-hook-pre-restore-history` - deprecated
+
+  Called after panes and layout have been restores, but before bash history is
+  restored (if it is enabled) -- the hook is always called even if history
+  saving is disabled.
+
+- `@resurrect-hook-pre-restore-pane-processes`
+
+  Called after history is restored, but before running processes are restored.
+
+### Examples
+
+Here is an example how to save and restore window geometry for most terminals in X11.
+Add this to `.tmux.conf`:
+
+    set -g @resurrect-hook-post-save-all 'eval $(xdotool getwindowgeometry --shell $WINDOWID); echo 0,$X,$Y,$WIDTH,$HEIGHT > $HOME/.tmux/resurrect/geometry'
+    set -g @resurrect-hook-pre-restore-all 'wmctrl -i -r $WINDOWID -e $(cat $HOME/.tmux/resurrect/geometry)'

docs/migrating_from_tmuxinator.md

@@ -0,0 +1,72 @@
+# Migrating from `tmuxinator`
+
+### Why migrate to `tmux-resurrect`?
+
+Here are some reasons why you'd want to migrate from `tmuxinator` to
+`tmux-resurrect`:
+
+- **Less dependencies**<br/>
+  `tmuxinator` depends on `ruby` which can be a hassle to set up if you're not a
+  rubyist.<br/>
+  `tmux-resurrect` depends just on `bash` which is virtually
+  omnipresent.
+
+- **Simplicity**<br/>
+  `tmuxinator` has an executable, CLI interface with half dozen commands and
+  command completion.<br/>
+  `tmux-resurrect` defines just 2 tmux key bindings.
+
+- **No configuration**<br/>
+  `tmuxinator` is all about config files (and their constant updating).<br/>
+  `tmux-resurrect` requires no configuration to work.
+
+- **Better change handling**<br/>
+  When you make a change to any aspect of tmux layout, you also have to
+  update related `tmuxinator` project file (and test to make sure change is
+  ok).<br/>
+  With `tmux-resurrect` there's nothing to do: your change will be
+  remembered on the next save.
+
+### How to migrate?
+
+1. Install `tmux-resurrect`.
+2. Open \*all* existing `tmuxinator` projects.<br/>
+   Verify all projects are open by pressing `prefix + s` and checking they are
+   all on the list.
+3. Perform a `tmux-resurrect` save.
+
+That's it! You can continue using just `tmux-resurrect` should you choose so.
+
+Note: it probably makes no sense to use both tools at the same time as they do
+the same thing (creating tmux environment for you to work in).
+Technically however, there should be no issues.
+
+### Usage differences
+
+`tmuxinator` focuses on managing individual tmux sessions (projects).
+`tmux-resurrect` keeps track of the \*whole* tmux environment: all sessions are
+saved and restored together.
+
+A couple tips if you decide to switch to `tmux-resurrect`:
+
+- Keep all tmux sessions (projects) running all the time.<br/>
+  If you want to work on an existing project, you should be able to just
+  \*switch* to an already open session using `prefix + s`.<br/>
+  This is different from `tmuxinator` where you'd usually run `mux new [project]`
+  in order to start working on something.
+
+- No need to kill sessions with `tmux kill-session` (unless you really don't
+  want to work on it ever).<br/>
+  It's the recurring theme by now: just keep all the sessions running all the
+  time. This is convenient and also cheap in terms of resources.
+
+- The only 2 situations when you need `tmux-resurrect`:<br/>
+  1) Save tmux environment just before restarting/shutting down your
+  computer.<br/>
+  2) Restore tmux env after you turn the computer on.
+
+### Other questions?
+
+Still have questions? Feel free to open an
+[issue](ihttps://github.com/tmux-plugins/tmux-resurrect/issues). We'll try to
+answer it and also update this doc.

docs/restoring_pane_contents.md

@@ -0,0 +1,31 @@
+# Restoring pane contents
+
+This plugin enables saving and restoring tmux pane contents.
+
+This feature can be enabled by adding this line to `.tmux.conf`:
+
+    set -g @resurrect-capture-pane-contents 'on'
+
+##### Known issue
+
+When using this feature, please check the value of `default-command`
+tmux option. That can be done with `$ tmux show -g default-command`.
+
+The value should NOT contain `&&` or `||` operators. If it does, simplify the
+option so those operators are removed.
+
+Example:
+
+- this will cause issues (notice the `&&` and `||` operators):
+
+        set -g default-command "which reattach-to-user-namespace > /dev/null && reattach-to-user-namespace -l $SHELL || $SHELL -l"
+
+- this is ok:
+
+        set -g default-command "reattach-to-user-namespace -l $SHELL"
+
+Related [bug](https://github.com/tmux-plugins/tmux-resurrect/issues/98).
+
+Alternatively, you can let
+[tmux-sensible](https://github.com/tmux-plugins/tmux-sensible)
+handle this option in a cross-platform way and you'll have no problems.

docs/restoring_previously_saved_environment.md

@@ -0,0 +1,13 @@
+# Restoring previously saved environment
+
+None of the previous saves are deleted (unless you explicitly do that). All save
+files are kept in `~/.tmux/resurrect/` directory.<br/>
+Here are the steps to restore to a previous point in time:
+
+- make sure you start this with a "fresh" tmux instance
+- `$ cd ~/.tmux/resurrect/`
+- locate the save file you'd like to use for restore (file names have a timestamp)
+- symlink the `last` file to the desired save file: `$ ln -sf <file_name> last`
+- do a restore with `tmux-resurrect` key: `prefix + Ctrl-r`
+
+You should now be restored to the time when `<file_name>` save happened.

docs/restoring_programs.md

@@ -0,0 +1,187 @@
+# Restoring programs
+  - [General instructions](#general-instructions)
+  - [Clarifications](#clarifications)
+  - [Working with NodeJS](#nodejs)
+  - [Restoring Mosh](#mosh)
+
+### General instructions <a name="general-instructions"></a>
+Only a conservative list of programs is restored by default:<br/>
+`vi vim nvim emacs man less more tail top htop irssi weechat mutt`.
+
+This can be configured with `@resurrect-processes` option in `.tmux.conf`. It
+contains space-separated list of additional programs to restore.
+
+- Example restoring additional programs:
+
+        set -g @resurrect-processes 'ssh psql mysql sqlite3'
+
+- Programs with arguments should be double quoted:
+
+        set -g @resurrect-processes 'some_program "git log"'
+
+- Start with tilde to restore a program whose process contains target name:
+
+        set -g @resurrect-processes 'irb pry "~rails server" "~rails console"'
+
+- Use `->` to specify a command to be used when restoring a program (useful if
+  the default restore command fails ):
+
+        set -g @resurrect-processes 'some_program "grunt->grunt development"'
+
+- Don't restore any programs:
+
+        set -g @resurrect-processes 'false'
+
+- Restore **all** programs (dangerous!):
+
+        set -g @resurrect-processes ':all:'
+
+  Be *very careful* with this: tmux-resurrect can not know which programs take
+  which context, and a `sudo mkfs.vfat /dev/sdb` that was just formatting an
+  external USB stick could wipe your backup hard disk if that's what's attached
+  after rebooting.
+
+  This option is primarily useful for experimentation (e.g., to find out which
+  program is recognized in a pane).
+
+### Clarifications <a name="clarfications"></a>
+
+> I don't understand tilde `~`, what is it and why is it used when restoring
+  programs?
+
+Let's say you use `rails server` command often. You want `tmux-resurrect` to
+save and restore it automatically. You might try adding `rails server` to the
+list of programs that will be restored:
+
+    set -g @resurrect-processes '"rails server"'  # will NOT work
+
+Upon save, `rails server` command will actually be saved as this command:
+`/Users/user/.rbenv/versions/2.0.0-p481/bin/ruby script/rails server`
+(if you wanna see how is any command saved, check it yourself in
+`~/.tmux/resurrect/last` file).
+
+When programs are restored, the `rails server` command will NOT be restored
+because it does not **strictly** match the long
+`/Users/user/.rbenv/versions/2.0.0-p481/bin/ruby script/rails server` string.
+
+The tilde `~` at the start of the string relaxes process name matching.
+
+    set -g @resurrect-processes '"~rails server"'  # OK
+
+The above option says: "restore full process if `rails server` string is found
+ANYWHERE in the process name".
+
+If you check long process string, there is in fact a `rails server` string at
+the end, so now the process will be successfully restored.
+
+> What is arrow `->` and why is is used?
+
+(Please read the above clarification about tilde `~`).
+
+Continuing with our `rails server` example, when the process is finally restored
+correctly it might not look pretty as you'll see the whole
+`/Users/user/.rbenv/versions/2.0.0-p481/bin/ruby script/rails server` string in
+the command line.
+
+Naturally, you'd rather want to see just `rails server` (what you initially
+typed), but that information is now unfortunately lost.
+
+To aid this, you can use arrow `->`: (**note**: there is no space before and after `->`)
+
+    set -g @resurrect-processes '"~rails server->rails server"'  # OK
+
+This option says: "when this process is restored use `rails server` as the
+command name".
+
+Full (long) process name is now ignored and you'll see just `rails server` in
+the command line when the program is restored.
+
+> Now I understand the tilde and the arrow, but things still don't work for me
+
+Here's the general workflow for figuring this out:
+
+- Set up your whole tmux environment manually.<br/>
+  In our example case, we'd type `rails server` in a pane where we want it to
+  run.
+- Save tmux env (it will get saved to `~/.tmux/resurrect/last`).
+- Open `~/.tmux/resurrect/last` file and try to find full process string for
+  your program.<br/>
+  Unfortunately this is a little vague but it should be easy. A smart
+  thing to do for our example is to search for string `rails` in the `last`
+  file.
+- Now that you know the full and the desired process string use tilde `~` and
+  arrow `->` in `.tmux.conf` to make things work.
+
+### Working with NodeJS <a name="nodejs"></a>
+If you are working with NodeJS, you may get some troubles with configuring restoring programs.
+
+Particularly, some programs like `gulp`, `grunt` or `npm` are not saved with parameters so tmux-resurrect cannot restore it. This is actually **not tmux-resurrect's issue** but more likely, those programs' issues. For example if you run `gulp watch` or `npm start` and then try to look at `ps` or `pgrep`, you will only see `gulp` or `npm`.
+
+To deal with these issues, one solution is to use [yarn](https://yarnpkg.com/en/docs/install) which a package manager for NodeJS and an alternative for `npm`. It's nearly identical to `npm` and very easy to use. Therefore you don't have to do any migration, you can simply use it immediately. For example:
+- `npm test` is equivalent to `yarn test`,
+- `npm run watch:dev` is equivalent to `yarn watch:dev`
+- more interestingly, `gulp watch:dev` is equivalent to `yarn gulp watch:dev`
+
+Before continuing, please ensure that you understand the [clarifications](#clarifications) section about `~` and `->`
+
+#### yarn
+It's fairly straight forward if you have been using `yarn` already.
+
+    set -g @resurrect-processes '"~yarn watch"'
+    set -g @resurrect-processes '"~yarn watch->yarn watch"'
+
+
+#### npm
+Instead of
+
+    set -g @resurrect-processes '"~npm run watch"'  # will NOT work
+
+we use
+
+    set -g @resurrect-processes '"~yarn watch"'     # OK
+
+
+#### gulp
+Instead of
+
+    set -g @resurrect-processes '"~gulp test"'      # will NOT work
+
+we use
+
+    set -g @resurrect-processes '"~yarn gulp test"' # OK
+
+
+#### nvm
+If you use `nvm` in your project, here is how you could config tmux-resurrect:
+
+    set -g @resurrect-processes '"~yarn gulp test->nvm use && gulp test"'
+
+#### Another problem
+Let take a look at this example
+
+    set -g @resurrect-processes '\
+          "~yarn gulp test->gulp test" \
+          "~yarn gulp test-it->gulp test-it" \
+    '
+**This will not work properly**, only `gulp test` is run, although you can see the command `node /path/to/yarn gulp test-it` is added correctly in `.tmux/resurrect/last` file.
+
+The reason is when restoring program, the **command part after the dash `-` is ignored** so instead  of command `gulp test-it`, the command `gulp test` which will be run.
+
+A work around, for this problem until it's fixed, is:
+- the config should be like this:
+
+      set -g @resurrect-processes '\
+          "~yarn gulp test->gulp test" \
+          "~yarn gulp \"test-it\"->gulp test-it" \
+
+- and in `.tmux/resurrect/last`, we should add quote to `test-it` word
+
+      ... node:node /path/to/yarn gulp "test-it"
+
+
+### Restoring Mosh <a name="#mosh"></a>
+Mosh spawns a `mosh-client` process, so we need to specify that as the process to be resurrected.
+
+    set -g @resurrect-processes 'mosh-client'
+
+Additionally a mosh-client strategy is provided to handle extracting the original arguments and re-run Mosh.

docs/restoring_shell_history.md

@@ -0,0 +1,23 @@
+# Restoring shell history (deprecated, do not use)
+
+This feature is deprecated because it's very invasive. It will be removed in
+the future with no replacement. To see problems it causes check
+[this issue](https://github.com/tmux-plugins/tmux-resurrect/issues/288).
+
+**Supported shells**: `bash` and `zsh`.
+
+Enable feature with this option in `.tmux.conf`:
+
+    set -g @resurrect-save-shell-history 'on'
+
+**Note**: the older `@resurrect-save-bash-history` is now an alias to
+`@resurrect-save-shell-history`.
+
+Shell `history` for individual panes will now be saved and restored. Due to
+technical limitations, this only works for panes which have no program running
+in foreground when saving. `tmux-resurrect` will send history write command to
+each such pane.
+
+To prevent these commands from being added to `bash` history
+themselves, add `HISTCONTROL=ignoreboth` to your `.bashrc`
+(this is set by default in Ubuntu).

docs/restoring_vim_and_neovim_sessions.md

@@ -0,0 +1,19 @@
+# Restoring vim and neovim sessions
+
+- save vim/neovim sessions. I recommend
+  [tpope/vim-obsession](https://github.com/tpope/vim-obsession) (as almost every
+  plugin, it works for both vim and neovim).
+- in `.tmux.conf`:
+
+        # for vim
+        set -g @resurrect-strategy-vim 'session'
+        # for neovim
+        set -g @resurrect-strategy-nvim 'session'
+
+`tmux-resurrect` will now restore vim and neovim sessions if `Session.vim` file
+is present.
+
+> If you're using the vim binary provided by MacVim.app then you'll need to set `@resurrect-processes`, for example:
+> ```
+> set -g @resurrect-processes '~Vim -> vim'
+> ```

docs/save_dir.md

@@ -0,0 +1,15 @@
+# Resurrect save dir
+
+By default Tmux environment is saved to a file in `~/.tmux/resurrect` dir.
+Change this with:
+
+    set -g @resurrect-dir '/some/path'
+
+Using environment variables or shell interpolation in this option is not
+allowed as the string is used literally. So the following won't do what is
+expected:
+
+    set -g @resurrect-dir '/path/$MY_VAR/$(some_executable)'
+
+Only the following variables and special chars are allowed:
+`$HOME`, `$HOSTNAME`, and `~`.

resurrect.tmux

@@ -22,12 +22,19 @@ set_restore_bindings() {
 }
 
 set_default_strategies() {
-	tmux set-option -g "${restore_process_strategy_option}irb" "default_strategy"
+	tmux set-option -gq "${restore_process_strategy_option}irb" "default_strategy"
+	tmux set-option -gq "${restore_process_strategy_option}mosh-client" "default_strategy"
+}
+
+set_script_path_options() {
+	tmux set-option -gq "$save_path_option" "$CURRENT_DIR/scripts/save.sh"
+	tmux set-option -gq "$restore_path_option" "$CURRENT_DIR/scripts/restore.sh"
 }
 
 main() {
 	set_save_bindings
 	set_restore_bindings
 	set_default_strategies
+	set_script_path_options
 }
 main

run_tests

@@ -0,0 +1 @@
+lib/tmux-test/run_tests

save_command_strategies/linux_procfs.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+PANE_PID="$1"
+COMMAND_PID=$(pgrep -P $PANE_PID)
+
+exit_safely_if_empty_ppid() {
+	if [ -z "$PANE_PID" ]; then
+		exit 0
+	fi
+}
+
+full_command() {
+	[[ -z "$COMMAND_PID" ]] && exit 0
+	cat /proc/${COMMAND_PID}/cmdline | xargs -0 printf "%q "
+}
+
+main() {
+	exit_safely_if_empty_ppid
+	full_command
+}
+main

save_command_strategies/ps.sh

@@ -10,16 +10,8 @@ exit_safely_if_empty_ppid() {
 	fi
 }
 
-ps_command_flags() {
-	case $(uname -s) in
-		FreeBSD) echo "-ao" ;;
-		OpenBSD) echo "-ao" ;;
-		*) echo "-eo" ;;
-	esac
-}
-
 full_command() {
-	ps "$(ps_command_flags)" "ppid command" |
+	ps -ao "ppid command" |
 		sed "s/^ *//" |
 		grep "^${PANE_PID}" |
 		cut -d' ' -f2-

scripts/helpers.sh

@@ -2,6 +2,10 @@ default_resurrect_dir="$HOME/.tmux/resurrect"
 resurrect_dir_option="@resurrect-dir"
 
 SUPPORTED_VERSION="1.9"
+RESURRECT_FILE_PREFIX="tmux_resurrect"
+RESURRECT_FILE_EXTENSION="txt"
+_RESURRECT_DIR=""
+_RESURRECT_FILE_PATH=""
 
 d=$'\t'
 
@@ -51,11 +55,22 @@ remove_first_char() {
 	echo "$1" | cut -c2-
 }
 
-save_bash_history_option_on() {
-	local option="$(get_tmux_option "$bash_history_option" "off")"
+capture_pane_contents_option_on() {
+	local option="$(get_tmux_option "$pane_contents_option" "off")"
 	[ "$option" == "on" ]
 }
 
+files_differ() {
+	! cmp -s "$1" "$2"
+}
+
+save_shell_history_option_on() {
+	local option_shell="$(get_tmux_option "$shell_history_option" "off")"
+	local option_bash="$(get_tmux_option "$bash_history_option" "off")"
+
+	[ "$option_shell" == "on" ] || [ "$option_bash" == "on" ]
+}
+
 get_grouped_sessions() {
 	local grouped_sessions_dump="$1"
 	export GROUPED_SESSIONS="${d}$(echo "$grouped_sessions_dump" | cut -f2 -d"$d" | tr "\\n" "$d")"
@@ -66,29 +81,88 @@ is_session_grouped() {
 	[[ "$GROUPED_SESSIONS" == *"${d}${session_name}${d}"* ]]
 }
 
+# pane content file helpers
+
+pane_contents_create_archive() {
+	tar cf - -C "$(resurrect_dir)/save/" ./pane_contents/ |
+		gzip > "$(pane_contents_archive_file)"
+}
+
+pane_content_files_restore_from_archive() {
+	local archive_file="$(pane_contents_archive_file)"
+	if [ -f "$archive_file" ]; then
+		mkdir -p "$(pane_contents_dir "restore")"
+		gzip -d < "$archive_file" |
+			tar xf - -C "$(resurrect_dir)/restore/"
+	fi
+}
+
 # path helpers
 
 resurrect_dir() {
-	echo $(get_tmux_option "$resurrect_dir_option" "$default_resurrect_dir")
+	if [ -z "$_RESURRECT_DIR" ]; then
+		local path="$(get_tmux_option "$resurrect_dir_option" "$default_resurrect_dir")"
+		# expands tilde, $HOME and $HOSTNAME if used in @resurrect-dir
+		echo "$path" | sed "s,\$HOME,$HOME,g; s,\$HOSTNAME,$(hostname),g; s,\~,$HOME,g"
+	else
+		echo "$_RESURRECT_DIR"
+	fi
 }
+_RESURRECT_DIR="$(resurrect_dir)"
 
 resurrect_file_path() {
-	local timestamp="$(date +"%Y-%m-%dT%H:%M:%S")"
-	echo "$(resurrect_dir)/tmux_resurrect_${timestamp}.txt"
+	if [ -z "$_RESURRECT_FILE_PATH" ]; then
+		local timestamp="$(date +"%Y%m%dT%H%M%S")"
+		echo "$(resurrect_dir)/${RESURRECT_FILE_PREFIX}_${timestamp}.${RESURRECT_FILE_EXTENSION}"
+	else
+		echo "$_RESURRECT_FILE_PATH"
+	fi
 }
+_RESURRECT_FILE_PATH="$(resurrect_file_path)"
 
 last_resurrect_file() {
 	echo "$(resurrect_dir)/last"
 }
 
-resurrect_history_file() {
-	local pane_id="$1"
-	echo "$(resurrect_dir)/bash_history-${pane_id}"
+pane_contents_dir() {
+	echo "$(resurrect_dir)/$1/pane_contents/"
 }
 
-restore_zoomed_windows() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $6 ~ /Z/ && $9 == 1 { print $2, $3; }' $(last_resurrect_file) |
-		while IFS=$d read session_name window_number; do
-			tmux resize-pane -t "${session_name}:${window_number}" -Z
-		done
+pane_contents_file() {
+	local save_or_restore="$1"
+	local pane_id="$2"
+	echo "$(pane_contents_dir "$save_or_restore")/pane-${pane_id}"
+}
+
+pane_contents_file_exists() {
+	local pane_id="$1"
+	[ -f "$(pane_contents_file "restore" "$pane_id")" ]
+}
+
+pane_contents_archive_file() {
+	echo "$(resurrect_dir)/pane_contents.tar.gz"
+}
+
+resurrect_history_file() {
+	local pane_id="$1"
+	local shell_name="$2"
+	echo "$(resurrect_dir)/${shell_name}_history-${pane_id}"
+}
+
+execute_hook() {
+	local kind="$1"
+	shift
+	local args="" hook=""
+
+	hook=$(get_tmux_option "$hook_prefix$kind" "")
+
+	# If there are any args, pass them to the hook (in a way that preserves/copes
+	# with spaces and unusual characters.
+	if [ "$#" -gt 0 ]; then
+		printf -v args "%q " "$@"
+	fi
+
+	if [ -n "$hook" ]; then
+		eval "$hook $args"
+	fi
 }

scripts/process_restore_helpers.sh

@@ -13,6 +13,7 @@ restore_pane_process() {
 	local window_number="$3"
 	local pane_index="$4"
 	local dir="$5"
+	local command
 	if _process_should_be_restored "$pane_full_command" "$session_name" "$window_number" "$pane_index"; then
 		tmux switch-client -t "${session_name}:${window_number}"
 		tmux select-pane -t "$pane_index"
@@ -20,15 +21,21 @@ restore_pane_process() {
 		local inline_strategy="$(_get_inline_strategy "$pane_full_command")" # might not be defined
 		if [ -n "$inline_strategy" ]; then
 			# inline strategy exists
-			tmux send-keys "$inline_strategy" "C-m"
+			# check for additional "expansion" of inline strategy, e.g. `vim` to `vim -S`
+			if _strategy_exists "$inline_strategy"; then
+				local strategy_file="$(_get_strategy_file "$inline_strategy")"
+				local inline_strategy="$($strategy_file "$pane_full_command" "$dir")"
+			fi
+			command="$inline_strategy"
 		elif _strategy_exists "$pane_full_command"; then
 			local strategy_file="$(_get_strategy_file "$pane_full_command")"
 			local strategy_command="$($strategy_file "$pane_full_command" "$dir")"
-			tmux send-keys "$strategy_command" "C-m"
+			command="$strategy_command"
 		else
-			# just invoke the command
-			tmux send-keys "$pane_full_command" "C-m"
+			# just invoke the raw command
+			command="$pane_full_command"
 		fi
+		tmux send-keys -t "${session_name}:${window_number}.${pane_index}" "$command" "C-m"
 	fi
 }
 
@@ -105,6 +112,32 @@ _get_proc_restore_element() {
 	echo "$1" | sed "s/.*${inline_strategy_token}//"
 }
 
+# given full command: 'ruby /Users/john/bin/my_program arg1 arg2'
+# and inline strategy: '~bin/my_program->my_program *'
+# returns: 'arg1 arg2'
+_get_command_arguments() {
+	local pane_full_command="$1"
+	local match="$2"
+	if _proc_starts_with_tildae "$match"; then
+		match="$(remove_first_char "$match")"
+	fi
+	echo "$pane_full_command" | sed "s,^.*${match}[^ ]* ,,"
+}
+
+_get_proc_restore_command() {
+	local pane_full_command="$1"
+	local proc="$2"
+	local match="$3"
+	local restore_element="$(_get_proc_restore_element "$proc")"
+	if [[ "$restore_element" =~ " ${inline_strategy_arguments_token}" ]]; then
+		# replaces "%" with command arguments
+		local command_arguments="$(_get_command_arguments "$pane_full_command" "$match")"
+		echo "$restore_element" | sed "s/${inline_strategy_arguments_token}/${command_arguments}/"
+	else
+		echo "$restore_element"
+	fi
+}
+
 _restore_list() {
 	local user_processes="$(get_tmux_option "$restore_processes_option" "$restore_processes")"
 	local default_processes="$(get_tmux_option "$default_proc_list_option" "$default_proc_list")"
@@ -130,7 +163,7 @@ _get_inline_strategy() {
 		if [[ "$proc" =~ "$inline_strategy_token" ]]; then
 			match="$(_get_proc_match_element "$proc")"
 			if _proc_matches_full_command "$pane_full_command" "$match"; then
-				echo "$(_get_proc_restore_element "$proc")"
+				echo "$(_get_proc_restore_command "$pane_full_command" "$proc" "$match")"
 			fi
 		fi
 	done

scripts/restore.sh

@@ -16,6 +16,10 @@ d=$'\t'
 # is also not restored. That makes the restoration process more idempotent.
 EXISTING_PANES_VAR=""
 
+RESTORING_FROM_SCRATCH="false"
+
+RESTORE_PANE_CONTENTS="false"
+
 is_line_type() {
 	local line_type="$1"
 	local line="$2"
@@ -56,6 +60,30 @@ is_pane_registered_as_existing() {
 	[[ "$EXISTING_PANES_VAR" =~ "$pane_custom_id" ]]
 }
 
+restore_from_scratch_true() {
+	RESTORING_FROM_SCRATCH="true"
+}
+
+is_restoring_from_scratch() {
+	[ "$RESTORING_FROM_SCRATCH" == "true" ]
+}
+
+restore_pane_contents_true() {
+	RESTORE_PANE_CONTENTS="true"
+}
+
+is_restoring_pane_contents() {
+	[ "$RESTORE_PANE_CONTENTS" == "true" ]
+}
+
+restored_session_0_true() {
+	RESTORED_SESSION_0="true"
+}
+
+has_restored_session_0() {
+	[ "$RESTORED_SESSION_0" == "true" ]
+}
+
 window_exists() {
 	local session_name="$1"
 	local window_number="$2"
@@ -76,20 +104,52 @@ tmux_socket() {
 	echo $TMUX | cut -d',' -f1
 }
 
+# Tmux option stored in a global variable so that we don't have to "ask"
+# tmux server each time.
+cache_tmux_default_command() {
+	local default_shell="$(get_tmux_option "default-shell" "")"
+	local opt=""
+	if [ "$(basename "$default_shell")" == "bash" ]; then
+		opt="-l "
+	fi
+	export TMUX_DEFAULT_COMMAND="$(get_tmux_option "default-command" "$opt$default_shell")"
+}
+
+tmux_default_command() {
+	echo "$TMUX_DEFAULT_COMMAND"
+}
+
+pane_creation_command() {
+	echo "cat '$(pane_contents_file "restore" "${1}:${2}.${3}")'; exec $(tmux_default_command)"
+}
+
 new_window() {
 	local session_name="$1"
 	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	tmux new-window -d -t "${session_name}:${window_number}" -n "$window_name" -c "$dir"
+	local dir="$3"
+	local pane_index="$4"
+	local pane_id="${session_name}:${window_number}.${pane_index}"
+	dir="${dir/#\~/$HOME}"
+	if is_restoring_pane_contents && pane_contents_file_exists "$pane_id"; then
+		local pane_creation_command="$(pane_creation_command "$session_name" "$window_number" "$pane_index")"
+		tmux new-window -d -t "${session_name}:${window_number}" -c "$dir" "$pane_creation_command"
+	else
+		tmux new-window -d -t "${session_name}:${window_number}" -c "$dir"
+	fi
 }
 
 new_session() {
 	local session_name="$1"
 	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	TMUX="" tmux -S "$(tmux_socket)" new-session -d -s "$session_name" -n "$window_name" -c "$dir"
+	local dir="$3"
+	local pane_index="$4"
+	local pane_id="${session_name}:${window_number}.${pane_index}"
+	if is_restoring_pane_contents && pane_contents_file_exists "$pane_id"; then
+		local pane_creation_command="$(pane_creation_command "$session_name" "$window_number" "$pane_index")"
+		TMUX="" tmux -S "$(tmux_socket)" new-session -d -s "$session_name" -c "$dir" "$pane_creation_command"
+	else
+		TMUX="" tmux -S "$(tmux_socket)" new-session -d -s "$session_name" -c "$dir"
+	fi
 	# change first window number if necessary
 	local created_window_num="$(first_window_num)"
 	if [ $created_window_num -ne $window_number ]; then
@@ -100,30 +160,48 @@ new_session() {
 new_pane() {
 	local session_name="$1"
 	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	tmux split-window -t "${session_name}:${window_number}" -c "$dir"
+	local dir="$3"
+	local pane_index="$4"
+	local pane_id="${session_name}:${window_number}.${pane_index}"
+	if is_restoring_pane_contents && pane_contents_file_exists "$pane_id"; then
+		local pane_creation_command="$(pane_creation_command "$session_name" "$window_number" "$pane_index")"
+		tmux split-window -t "${session_name}:${window_number}" -c "$dir" "$pane_creation_command"
+	else
+		tmux split-window -t "${session_name}:${window_number}" -c "$dir"
+	fi
 	# minimize window so more panes can fit
-	tmux resize-pane  -t "${session_name}:${window_number}" -U "999"
+	tmux resize-pane -t "${session_name}:${window_number}" -U "999"
 }
 
 restore_pane() {
 	local pane="$1"
-	while IFS=$d read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active pane_command pane_full_command; do
+	while IFS=$d read line_type session_name window_number window_active window_flags pane_index pane_title dir pane_active pane_command pane_full_command; do
 		dir="$(remove_first_char "$dir")"
-		window_name="$(remove_first_char "$window_name")"
 		pane_full_command="$(remove_first_char "$pane_full_command")"
-		if pane_exists "$session_name" "$window_number" "$pane_index"; then
-			# Pane exists, no need to create it!
-			# Pane existence is registered. Later, it's process also isn't restored.
-			register_existing_pane "$session_name" "$window_number" "$pane_index"
-		elif window_exists "$session_name" "$window_number"; then
-			new_pane "$session_name" "$window_number" "$window_name" "$dir"
-		elif session_exists "$session_name"; then
-			new_window "$session_name" "$window_number" "$window_name" "$dir"
-		else
-			new_session "$session_name" "$window_number" "$window_name" "$dir"
+		if [ "$session_name" == "0" ]; then
+			restored_session_0_true
 		fi
+		if pane_exists "$session_name" "$window_number" "$pane_index"; then
+			if is_restoring_from_scratch; then
+				# overwrite the pane
+				# happens only for the first pane if it's the only registered pane for the whole tmux server
+				local pane_id="$(tmux display-message -p -F "#{pane_id}" -t "$session_name:$window_number")"
+				new_pane "$session_name" "$window_number" "$dir" "$pane_index"
+				tmux kill-pane -t "$pane_id"
+			else
+				# Pane exists, no need to create it!
+				# Pane existence is registered. Later, its process also won't be restored.
+				register_existing_pane "$session_name" "$window_number" "$pane_index"
+			fi
+		elif window_exists "$session_name" "$window_number"; then
+			new_pane "$session_name" "$window_number" "$dir" "$pane_index"
+		elif session_exists "$session_name"; then
+			new_window "$session_name" "$window_number" "$dir" "$pane_index"
+		else
+			new_session "$session_name" "$window_number" "$dir" "$pane_index"
+		fi
+		# set pane title
+		tmux select-pane -t "$session_name:$window_number.$pane_index" -T "$pane_title"
 	done < <(echo "$pane")
 }
 
@@ -136,56 +214,6 @@ restore_state() {
 	done
 }
 
-restore_all_panes() {
-	while read line; do
-		if is_line_type "pane" "$line"; then
-			restore_pane "$line"
-		fi
-	done < $(last_resurrect_file)
-}
-
-restore_shell_history() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ { print $2, $3, $7, $10; }' $(last_resurrect_file) |
-		while IFS=$d read session_name window_number pane_index pane_command; do
-		 if ! is_pane_registered_as_existing "$session_name" "$window_number" "$pane_index"; then
-				if [ "$pane_command" = "bash" ]; then
-					local pane_id="$session_name:$window_number.$pane_index"
-					# tmux send-keys has -R option that should reset the terminal.
-					# However, appending 'clear' to the command seems to work more reliably.
-					local read_command="history -r '$(resurrect_history_file "$pane_id")'; clear"
-					tmux send-keys -t "$pane_id" "$read_command" C-m
-				fi
-			fi
-		done
-}
-
-restore_all_pane_processes() {
-	if restore_pane_processes_enabled; then
-		local pane_full_command
-		awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $11 !~ "^:$" { print $2, $3, $7, $8, $11; }' $(last_resurrect_file) |
-			while IFS=$d read session_name window_number pane_index dir pane_full_command; do
-				dir="$(remove_first_char "$dir")"
-				pane_full_command="$(remove_first_char "$pane_full_command")"
-				restore_pane_process "$pane_full_command" "$session_name" "$window_number" "$pane_index" "$dir"
-			done
-	fi
-}
-
-restore_pane_layout_for_each_window() {
-	\grep '^window' $(last_resurrect_file) |
-		while IFS=$d read line_type session_name window_number window_active window_flags window_layout; do
-			tmux select-layout -t "${session_name}:${window_number}" "$window_layout"
-		done
-}
-
-restore_active_pane_for_each_window() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $9 == 1 { print $2, $3, $7; }' $(last_resurrect_file) |
-		while IFS=$d read session_name window_number active_pane; do
-			tmux switch-client -t "${session_name}:${window_number}"
-			tmux select-pane -t "$active_pane"
-		done
-}
-
 restore_grouped_session() {
 	local grouped_session="$1"
 	echo "$grouped_session" |
@@ -209,6 +237,118 @@ restore_active_and_alternate_windows_for_grouped_sessions() {
 	done
 }
 
+never_ever_overwrite() {
+	local overwrite_option_value="$(get_tmux_option "$overwrite_option" "")"
+	[ -n "$overwrite_option_value" ]
+}
+
+detect_if_restoring_from_scratch() {
+	if never_ever_overwrite; then
+		return
+	fi
+	local total_number_of_panes="$(tmux list-panes -a | wc -l | sed 's/ //g')"
+	if [ "$total_number_of_panes" -eq 1 ]; then
+		restore_from_scratch_true
+	fi
+}
+
+detect_if_restoring_pane_contents() {
+	if capture_pane_contents_option_on; then
+		cache_tmux_default_command
+		restore_pane_contents_true
+	fi
+}
+
+# functions called from main (ordered)
+
+restore_all_panes() {
+	detect_if_restoring_from_scratch   # sets a global variable
+	detect_if_restoring_pane_contents  # sets a global variable
+	if is_restoring_pane_contents; then
+		pane_content_files_restore_from_archive
+	fi
+	while read line; do
+		if is_line_type "pane" "$line"; then
+			restore_pane "$line"
+		fi
+	done < $(last_resurrect_file)
+}
+
+handle_session_0() {
+	if is_restoring_from_scratch && ! has_restored_session_0; then
+		local current_session="$(tmux display -p "#{client_session}")"
+		if [ "$current_session" == "0" ]; then
+			tmux switch-client -n
+		fi
+		tmux kill-session -t "0"
+	fi
+}
+
+restore_window_properties() {
+	local window_name
+	\grep '^window' $(last_resurrect_file) |
+		while IFS=$d read line_type session_name window_number window_name window_active window_flags window_layout automatic_rename; do
+			tmux select-layout -t "${session_name}:${window_number}" "$window_layout"
+
+			# Below steps are properly handling window names and automatic-rename
+			# option. `rename-window` is an extra command in some scenarios, but we
+			# opted for always doing it to keep the code simple.
+			window_name="$(remove_first_char "$window_name")"
+			tmux rename-window -t "${session_name}:${window_number}" "$window_name"
+			if [ "${automatic_rename}" = ":" ]; then
+				tmux set-option -u -t "${session_name}:${window_number}" automatic-rename
+			else
+				tmux set-option -t "${session_name}:${window_number}" automatic-rename "$automatic_rename"
+			fi
+		done
+}
+
+restore_shell_history() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ { print $2, $3, $6, $9; }' $(last_resurrect_file) |
+		while IFS=$d read session_name window_number pane_index pane_command; do
+			if ! is_pane_registered_as_existing "$session_name" "$window_number" "$pane_index"; then
+				local pane_id="$session_name:$window_number.$pane_index"
+				local history_file="$(resurrect_history_file "$pane_id" "$pane_command")"
+
+				if [ "$pane_command" = "bash" ]; then
+					local read_command="history -r '$history_file'"
+					tmux send-keys -t "$pane_id" "$read_command" C-m
+				elif [ "$pane_command" = "zsh" ]; then
+					local accept_line="$(expr "$(zsh -i -c bindkey | grep -m1 '\saccept-line$')" : '^"\(.*\)".*')"
+					local read_command="fc -R '$history_file'; clear"
+					tmux send-keys -t "$pane_id" "$read_command" "$accept_line"
+				fi
+			fi
+		done
+}
+
+restore_all_pane_processes() {
+	if restore_pane_processes_enabled; then
+		local pane_full_command
+		awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $11 !~ "^:$" { print $2, $3, $6, $8, $11; }' $(last_resurrect_file) |
+			while IFS=$d read -r session_name window_number pane_index dir pane_full_command; do
+				dir="$(remove_first_char "$dir")"
+				pane_full_command="$(remove_first_char "$pane_full_command")"
+				restore_pane_process "$pane_full_command" "$session_name" "$window_number" "$pane_index" "$dir"
+			done
+	fi
+}
+
+restore_active_pane_for_each_window() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $9 == 1 { print $2, $3, $6; }' $(last_resurrect_file) |
+		while IFS=$d read session_name window_number active_pane; do
+			tmux switch-client -t "${session_name}:${window_number}"
+			tmux select-pane -t "$active_pane"
+		done
+}
+
+restore_zoomed_windows() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $5 ~ /Z/ && $9 == 1 { print $2, $3; }' $(last_resurrect_file) |
+		while IFS=$d read session_name window_number; do
+			tmux resize-pane -t "${session_name}:${window_number}" -Z
+		done
+}
+
 restore_grouped_sessions() {
 	while read line; do
 		if is_line_type "grouped_session" "$line"; then
@@ -219,7 +359,7 @@ restore_grouped_sessions() {
 }
 
 restore_active_and_alternate_windows() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^window/ && $5 ~ /[*-]/ { print $2, $4, $3; }' $(last_resurrect_file) |
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^window/ && $6 ~ /[*-]/ { print $2, $4, $3; }' $(last_resurrect_file) |
 		sort -u |
 		while IFS=$d read session_name active_window window_number; do
 			tmux switch-client -t "${session_name}:${window_number}"
@@ -234,14 +374,26 @@ restore_active_and_alternate_sessions() {
 	done < $(last_resurrect_file)
 }
 
+# A cleanup that happens after 'restore_all_panes' seems to fix fish shell
+# users' restore problems.
+cleanup_restored_pane_contents() {
+	if is_restoring_pane_contents; then
+		rm "$(pane_contents_dir "restore")"/*
+	fi
+}
+
 main() {
 	if supported_tmux_version_ok && check_saved_session_exists; then
 		start_spinner "Restoring..." "Tmux restore complete!"
+		execute_hook "pre-restore-all"
 		restore_all_panes
-		restore_pane_layout_for_each_window >/dev/null 2>&1
-		if save_bash_history_option_on; then
+		handle_session_0
+		restore_window_properties >/dev/null 2>&1
+		execute_hook "pre-restore-history"
+		if save_shell_history_option_on; then
 			restore_shell_history
 		fi
+		execute_hook "pre-restore-pane-processes"
 		restore_all_pane_processes
 		# below functions restore exact cursor positions
 		restore_active_pane_for_each_window
@@ -249,6 +401,8 @@ main() {
 		restore_grouped_sessions  # also restores active and alt windows for grouped sessions
 		restore_active_and_alternate_windows
 		restore_active_and_alternate_sessions
+		cleanup_restored_pane_contents
+		execute_hook "post-restore-all"
 		stop_spinner
 		display_message "Tmux restore complete!"
 	fi

scripts/save.sh

@@ -10,6 +10,9 @@ source "$CURRENT_DIR/spinner_helpers.sh"
 d=$'\t'
 delimiter=$'\t'
 
+# if "quiet" script produces no output
+SCRIPT_OUTPUT="$1"
+
 grouped_sessions_format() {
 	local format
 	format+="#{session_grouped}"
@@ -30,14 +33,14 @@ pane_format() {
 	format+="${delimiter}"
 	format+="#{window_index}"
 	format+="${delimiter}"
-	format+=":#{window_name}"
-	format+="${delimiter}"
 	format+="#{window_active}"
 	format+="${delimiter}"
 	format+=":#{window_flags}"
 	format+="${delimiter}"
 	format+="#{pane_index}"
 	format+="${delimiter}"
+	format+="#{pane_title}"
+	format+="${delimiter}"
 	format+=":#{pane_current_path}"
 	format+="${delimiter}"
 	format+="#{pane_active}"
@@ -45,6 +48,8 @@ pane_format() {
 	format+="#{pane_current_command}"
 	format+="${delimiter}"
 	format+="#{pane_pid}"
+	format+="${delimiter}"
+	format+="#{history_size}"
 	echo "$format"
 }
 
@@ -56,6 +61,8 @@ window_format() {
 	format+="${delimiter}"
 	format+="#{window_index}"
 	format+="${delimiter}"
+	format+=":#{window_name}"
+	format+="${delimiter}"
 	format+="#{window_active}"
 	format+="${delimiter}"
 	format+=":#{window_flags}"
@@ -82,6 +89,11 @@ dump_windows_raw(){
 	tmux list-windows -a -F "$(window_format)"
 }
 
+toggle_window_zoom() {
+	local target="$1"
+	tmux resize-pane -Z -t "$target"
+}
+
 _save_command_strategy_file() {
 	local save_command_strategy="$(get_tmux_option "$save_command_strategy_option" "$default_save_command_strategy")"
 	local strategy_file="$CURRENT_DIR/../save_command_strategies/${save_command_strategy}.sh"
@@ -100,17 +112,75 @@ pane_full_command() {
 	$strategy_file "$pane_pid"
 }
 
+number_nonempty_lines_on_screen() {
+	local pane_id="$1"
+	tmux capture-pane -pJ -t "$pane_id" |
+		sed '/^$/d' |
+		wc -l |
+		sed 's/ //g'
+}
+
+# tests if there was any command output in the current pane
+pane_has_any_content() {
+	local pane_id="$1"
+	local history_size="$(tmux display -p -t "$pane_id" -F "#{history_size}")"
+	local cursor_y="$(tmux display -p -t "$pane_id" -F "#{cursor_y}")"
+	# doing "cheap" tests first
+	[ "$history_size" -gt 0 ] || # history has any content?
+		[ "$cursor_y" -gt 0 ] || # cursor not in first line?
+		[ "$(number_nonempty_lines_on_screen "$pane_id")" -gt 1 ]
+}
+
+capture_pane_contents() {
+	local pane_id="$1"
+	local start_line="-$2"
+	local pane_contents_area="$3"
+	if pane_has_any_content "$pane_id"; then
+		if [ "$pane_contents_area" = "visible" ]; then
+			start_line="0"
+		fi
+		# the printf hack below removes *trailing* empty lines
+		printf '%s\n' "$(tmux capture-pane -epJ -S "$start_line" -t "$pane_id")" > "$(pane_contents_file "save" "$pane_id")"
+	fi
+}
+
 save_shell_history() {
+	if [ "$pane_command" = "bash" ]; then
+		local history_w='history -w'
+		local history_r='history -r'
+		local accept_line='C-m'
+		local end_of_line='C-e'
+		local backward_kill_line='C-u'
+	elif [ "$pane_command" = "zsh" ]; then
+		# fc -W does not work with -L
+		# fc -l format is different from what's written by fc -W
+		# fc -R either reads the format produced by fc -W or considers
+		# the entire line to be a command. That's why we need -n.
+		# fc -l only list the last 16 items by default, I think 64 is more reasonable.
+		local history_w='fc -lLn -64 >'
+		local history_r='fc -R'
+
+		local zsh_bindkey="$(zsh -i -c bindkey)"
+		local accept_line="$(expr "$(echo "$zsh_bindkey" | grep -m1 '\saccept-line$')" : '^"\(.*\)".*')"
+		local end_of_line="$(expr "$(echo "$zsh_bindkey" | grep -m1 '\send-of-line$')" : '^"\(.*\)".*')"
+		local backward_kill_line="$(expr "$(echo "$zsh_bindkey" | grep -m1 '\sbackward-kill-line$')" : '^"\(.*\)".*')"
+	else
+		return
+	fi
+
 	local pane_id="$1"
 	local pane_command="$2"
 	local full_command="$3"
-	if [ "$pane_command" = "bash" ] && [ "$full_command" = ":" ]; then
+	if [ "$full_command" = ":" ]; then
 		# leading space prevents the command from being saved to history
 		# (assuming default HISTCONTROL settings)
-		local write_command=" history -w '$(resurrect_history_file "$pane_id")'"
+		local write_command=" $history_w '$(resurrect_history_file "$pane_id" "$pane_command")'"
+		local read_command=" $history_r '$(resurrect_history_file "$pane_id" "$pane_command")'"
 		# C-e C-u is a Bash shortcut sequence to clear whole line. It is necessary to
 		# delete any pending input so it does not interfere with our history command.
-		tmux send-keys -t "$pane_id" C-e C-u "$write_command" C-m
+		tmux send-keys -t "$pane_id" "$end_of_line" "$backward_kill_line" "$write_command" "$accept_line"
+		# Immediately restore after saving
+		tmux send-keys -t "$pane_id" "$end_of_line" "$backward_kill_line" "$read_command" "$accept_line"
 	fi
 }
 
@@ -159,29 +229,28 @@ fetch_and_dump_grouped_sessions(){
 dump_panes() {
 	local full_command
 	dump_panes_raw |
-		while IFS=$d read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active pane_command pane_pid; do
+		while IFS=$d read line_type session_name window_number window_active window_flags pane_index pane_title dir pane_active pane_command pane_pid history_size; do
 			# not saving panes from grouped sessions
 			if is_session_grouped "$session_name"; then
 				continue
 			fi
-			# check if current pane is part of a maximized window and if the pane is active
-			if [[ "${window_flags}" == *Z* ]] && [[ ${pane_active} == 1 ]]; then
-				# unmaximize the pane
-				tmux resize-pane -Z -t "${session_name}:${window_number}"
-			fi
 			full_command="$(pane_full_command $pane_pid)"
-			echo "${line_type}${d}${session_name}${d}${window_number}${d}${window_name}${d}${window_active}${d}${window_flags}${d}${pane_index}${d}${dir}${d}${pane_active}${d}${pane_command}${d}:${full_command}"
+			dir=$(echo $dir | sed 's/ /\\ /') # escape all spaces in directory path
+			echo "${line_type}${d}${session_name}${d}${window_number}${d}${window_active}${d}${window_flags}${d}${pane_index}${d}${pane_title}${d}${dir}${d}${pane_active}${d}${pane_command}${d}:${full_command}"
 		done
 }
 
 dump_windows() {
 	dump_windows_raw |
-		while IFS=$d read line_type session_name window_index window_active window_flags window_layout; do
+		while IFS=$d read line_type session_name window_index window_name window_active window_flags window_layout; do
 			# not saving windows from grouped sessions
 			if is_session_grouped "$session_name"; then
 				continue
 			fi
-			echo "${line_type}${d}${session_name}${d}${window_index}${d}${window_active}${d}${window_flags}${d}${window_layout}"
+			automatic_rename="$(tmux show-window-options -vt "${session_name}:${window_index}" automatic-rename)"
+			# If the option was unset, use ":" as a placeholder.
+			[ -z "${automatic_rename}" ] && automatic_rename=":"
+			echo "${line_type}${d}${session_name}${d}${window_index}${d}${window_name}${d}${window_active}${d}${window_flags}${d}${window_layout}${d}${automatic_rename}"
 		done
 }
 
@@ -189,33 +258,71 @@ dump_state() {
 	tmux display-message -p "$(state_format)"
 }
 
-dump_bash_history() {
+dump_pane_contents() {
+	local pane_contents_area="$(get_tmux_option "$pane_contents_area_option" "$default_pane_contents_area")"
+	dump_panes_raw |
+		while IFS=$d read line_type session_name window_number window_active window_flags pane_index pane_title dir pane_active pane_command pane_pid history_size; do
+			capture_pane_contents "${session_name}:${window_number}.${pane_index}" "$history_size" "$pane_contents_area"
+		done
+}
+
+dump_shell_history() {
 	dump_panes |
-		while IFS=$d read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active pane_command full_command; do
+		while IFS=$d read line_type session_name window_number window_active window_flags pane_index dir pane_active pane_command full_command; do
 			save_shell_history "$session_name:$window_number.$pane_index" "$pane_command" "$full_command"
 		done
 }
 
+remove_old_backups() {
+	# remove resurrect files older than 30 days (default), but keep at least 5 copies of backup.
+	local delete_after="$(get_tmux_option "$delete_backup_after_option" "$default_delete_backup_after")"
+	local -a files
+	files=($(ls -t $(resurrect_dir)/${RESURRECT_FILE_PREFIX}_*.${RESURRECT_FILE_EXTENSION} | tail -n +6))
+	[[ ${#files[@]} -eq 0 ]] ||
+		find "${files[@]}" -type f -mtime "+${delete_after}" -exec rm -v "{}" \; > /dev/null
+}
+
 save_all() {
 	local resurrect_file_path="$(resurrect_file_path)"
+	local last_resurrect_file="$(last_resurrect_file)"
 	mkdir -p "$(resurrect_dir)"
 	fetch_and_dump_grouped_sessions > "$resurrect_file_path"
 	dump_panes   >> "$resurrect_file_path"
 	dump_windows >> "$resurrect_file_path"
 	dump_state   >> "$resurrect_file_path"
-	ln -fs "$(basename "$resurrect_file_path")" "$(last_resurrect_file)"
-	if save_bash_history_option_on; then
-		dump_bash_history
+	execute_hook "post-save-layout" "$resurrect_file_path"
+	if files_differ "$resurrect_file_path" "$last_resurrect_file"; then
+		ln -fs "$(basename "$resurrect_file_path")" "$last_resurrect_file"
+	else
+		rm "$resurrect_file_path"
 	fi
-	restore_zoomed_windows
+	if capture_pane_contents_option_on; then
+		mkdir -p "$(pane_contents_dir "save")"
+		dump_pane_contents
+		pane_contents_create_archive
+		rm "$(pane_contents_dir "save")"/*
+	fi
+	if save_shell_history_option_on; then
+		dump_shell_history
+	fi
+	remove_old_backups
+	execute_hook "post-save-all"
+}
+
+show_output() {
+	[ "$SCRIPT_OUTPUT" != "quiet" ]
 }
 
 main() {
 	if supported_tmux_version_ok; then
-		start_spinner "Saving..." "Tmux environment saved!"
+		if show_output; then
+			start_spinner "Saving..." "Tmux environment saved!"
+		fi
 		save_all
-		stop_spinner
-		display_message "Tmux environment saved!"
+		if show_output; then
+			stop_spinner
+			display_message "Tmux environment saved!"
+		fi
 	fi
 }
 main

scripts/variables.sh

@@ -1,13 +1,15 @@
 # key bindings
 default_save_key="C-s"
 save_option="@resurrect-save"
+save_path_option="@resurrect-save-script-path"
 
 default_restore_key="C-r"
 restore_option="@resurrect-restore"
+restore_path_option="@resurrect-restore-script-path"
 
 # default processes that are restored
 default_proc_list_option="@resurrect-default-processes"
-default_proc_list='vi vim nvim emacs man less more tail top htop irssi'
+default_proc_list='vi vim view nvim emacs man less more tail top htop irssi weechat mutt'
 
 # User defined processes that are restored
 #  'false' - nothing is restored
@@ -23,8 +25,27 @@ restore_processes=""
 restore_process_strategy_option="@resurrect-strategy-"
 
 inline_strategy_token="->"
+inline_strategy_arguments_token="*"
 
 save_command_strategy_option="@resurrect-save-command-strategy"
 default_save_command_strategy="ps"
 
-bash_history_option="@resurrect-save-bash-history"
+# Pane contents capture options.
+# @resurrect-pane-contents-area option can be:
+#   'visible' - capture only the visible pane area
+#   'full'    - capture the full pane contents
+pane_contents_option="@resurrect-capture-pane-contents"
+pane_contents_area_option="@resurrect-pane-contents-area"
+default_pane_contents_area="full"
+
+bash_history_option="@resurrect-save-bash-history" # deprecated
+shell_history_option="@resurrect-save-shell-history" # deprecated
+
+# set to 'on' to ensure panes are never ever overwritten
+overwrite_option="@resurrect-never-overwrite"
+
+# Hooks are set via ${hook_prefix}${name}, i.e. "@resurrect-hook-post-save-all"
+hook_prefix="@resurrect-hook-"
+
+delete_backup_after_option="@resurrect-delete-backup-after"
+default_delete_backup_after="30" # days

strategies/mosh-client_default_strategy.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# "mosh-client default strategy"
+#
+# Example mosh-client process:
+#   mosh-client -# charm tmux at | 198.199.104.142 60001
+#
+# When executed, the above will fail. This strategy handles that.
+
+ORIGINAL_COMMAND="$1"
+DIRECTORY="$2"
+
+mosh_command() {
+	local args="$ORIGINAL_COMMAND"
+
+	args="${args#*-#}"
+	args="${args%|*}"
+
+	echo "mosh $args"
+}
+
+main() {
+	echo "$(mosh_command)"
+}
+main

strategies/vim_session.sh

@@ -13,18 +13,9 @@ vim_session_file_exists() {
 	[ -e "${DIRECTORY}/Session.vim" ]
 }
 
-original_command_contains_session_flag() {
-	[[ "$ORIGINAL_COMMAND" =~ "-S" ]]
-}
-
 main() {
 	if vim_session_file_exists; then
 		echo "vim -S"
-	elif original_command_contains_session_flag; then
-		# Session file does not exist, yet the original vim command contains
-		# session flag `-S`. This will cause an error, so we're falling back to
-		# starting plain vim.
-		echo "vim"
 	else
 		echo "$ORIGINAL_COMMAND"
 	fi

tests/fixtures/restore_file.txt

@@ -0,0 +1,21 @@
+pane	0	0	:bash	1	:*	0	:/tmp	1	bash	:
+pane	blue	0	:vim	0	:	0	:/tmp	1	vim	:vim foo.txt
+pane	blue	1	:man	0	:-	0	:/tmp	0	bash	:
+pane	blue	1	:man	0	:-	1	:/usr/share/man	1	man	:man echo
+pane	blue	2	:bash	1	:*	0	:/tmp	1	bash	:
+pane	red	0	:bash	0	:	0	:/tmp	1	bash	:
+pane	red	1	:bash	0	:-Z	0	:/tmp	0	bash	:
+pane	red	1	:bash	0	:-Z	1	:/tmp	0	bash	:
+pane	red	1	:bash	0	:-Z	2	:/tmp	1	bash	:
+pane	red	2	:bash	1	:*	0	:/tmp	0	bash	:
+pane	red	2	:bash	1	:*	1	:/tmp	1	bash	:
+pane	yellow	0	:bash	1	:*	0	:/tmp/bar	1	bash	:
+window	0	0	1	:*	ce9e,200x49,0,0,1
+window	blue	0	0	:	ce9f,200x49,0,0,2
+window	blue	1	0	:-	178b,200x49,0,0{100x49,0,0,3,99x49,101,0,4}
+window	blue	2	1	:*	cea2,200x49,0,0,5
+window	red	0	0	:	cea3,200x49,0,0,6
+window	red	1	0	:-Z	135b,200x49,0,0[200x24,0,0,7,200x24,0,25{100x24,0,25,8,99x24,101,25,9}]
+window	red	2	1	:*	db81,200x49,0,0[200x24,0,0,10,200x24,0,25,11]
+window	yellow	0	1	:*	6781,200x49,0,0,12
+state	yellow	blue

tests/fixtures/save_file.txt

@@ -0,0 +1,21 @@
+pane	0	0	:bash	1	:*	0	:/tmp	1	bash	:
+pane	blue	0	:vim	0	:!	0	:/tmp	1	vim	:vim foo.txt
+pane	blue	1	:man	0	:!-	0	:/tmp	0	bash	:
+pane	blue	1	:man	0	:!-	1	:/usr/share/man	1	man	:man echo
+pane	blue	2	:bash	1	:*	0	:/tmp	1	bash	:
+pane	red	0	:bash	0	:	0	:/tmp	1	bash	:
+pane	red	1	:bash	0	:-Z	0	:/tmp	0	bash	:
+pane	red	1	:bash	0	:-Z	1	:/tmp	0	bash	:
+pane	red	1	:bash	0	:-Z	2	:/tmp	1	bash	:
+pane	red	2	:bash	1	:*	0	:/tmp	0	bash	:
+pane	red	2	:bash	1	:*	1	:/tmp	1	bash	:
+pane	yellow	0	:bash	1	:*	0	:/tmp/bar	1	bash	:
+window	0	0	1	:*	ce9d,200x49,0,0,0
+window	blue	0	0	:!	cea4,200x49,0,0,7
+window	blue	1	0	:!-	9797,200x49,0,0{100x49,0,0,8,99x49,101,0,9}
+window	blue	2	1	:*	677f,200x49,0,0,10
+window	red	0	0	:	ce9e,200x49,0,0,1
+window	red	1	0	:-Z	52b7,200x49,0,0[200x24,0,0,2,200x24,0,25{100x24,0,25,3,99x24,101,25,4}]
+window	red	2	1	:*	bd68,200x49,0,0[200x24,0,0,5,200x24,0,25,6]
+window	yellow	0	1	:*	6780,200x49,0,0,11
+state	yellow	blue

tests/helpers/create_and_save_tmux_test_environment.exp

@@ -0,0 +1,42 @@
+#!/usr/bin/env expect
+
+source "./tests/helpers/expect_helpers.exp"
+
+expect_setup
+
+spawn tmux
+# delay with sleep to compensate for tmux starting time
+sleep 1
+
+run_shell_command "cd /tmp"
+
+# session red
+new_tmux_session "red"
+
+new_tmux_window
+horizontal_split
+vertical_split
+toggle_zoom_pane
+
+new_tmux_window
+horizontal_split
+
+# session blue
+new_tmux_session "blue"
+
+run_shell_command "touch foo.txt"
+run_shell_command "vim foo.txt"
+
+new_tmux_window
+vertical_split
+run_shell_command "man echo"
+
+new_tmux_window
+
+# session yellow
+new_tmux_session "yellow"
+run_shell_command "cd /tmp/bar"
+
+start_resurrect_save
+
+run_shell_command "tmux kill-server"

tests/helpers/expect_helpers.exp

@@ -0,0 +1,70 @@
+# a set of expect helpers
+
+# basic setup for each script
+proc expect_setup {} {
+  # disables script output
+  log_user 0
+  # standard timeout
+  set timeout 5
+}
+
+proc new_tmux_window {} {
+  send "c"
+  send "cd /tmp\r"
+  sleep 0.2
+}
+
+proc rename_current_session {name} {
+  send "$"
+  # delete existing name with ctrl-u
+  send ""
+  send "$name\r"
+  sleep 0.2
+}
+
+proc new_tmux_session {name} {
+  send "TMUX='' tmux new -d -s $name\r"
+  sleep 1
+  send "tmux switch-client -t $name\r"
+  send "cd /tmp\r"
+  sleep 0.5
+}
+
+proc horizontal_split {} {
+  send "\""
+  sleep 0.2
+  send "cd /tmp\r"
+  sleep 0.1
+}
+
+proc vertical_split {} {
+  send "%"
+  sleep 0.2
+  send "cd /tmp\r"
+  sleep 0.1
+}
+
+proc toggle_zoom_pane {} {
+  send "z"
+  sleep 0.2
+}
+
+proc run_shell_command {command} {
+  send "$command\r"
+  sleep 1
+}
+
+proc start_resurrect_save {} {
+  send ""
+  sleep 5
+}
+
+proc start_resurrect_restore {} {
+  send ""
+  sleep 10
+}
+
+proc clear_screen_for_window {target} {
+  send "tmux send-keys -t $target C-l\r"
+  sleep 0.2
+}

tests/helpers/helpers.sh

@@ -0,0 +1 @@
+../../lib/tmux-test/tests/helpers/helpers.sh

tests/helpers/restore_and_save_tmux_test_environment.exp

@@ -0,0 +1,18 @@
+#!/usr/bin/env expect
+
+source "./tests/helpers/expect_helpers.exp"
+
+expect_setup
+
+spawn tmux
+# delay with sleep to compensate for tmux starting time
+sleep 1
+
+start_resurrect_restore
+
+# delete all existing resurrect save files
+run_shell_command "rm ~/.tmux/resurrect/*"
+
+start_resurrect_save
+
+run_shell_command "tmux kill-server"

tests/helpers/resurrect_helpers.sh

@@ -0,0 +1,11 @@
+# we want "fixed" dimensions no matter the size of real display
+set_screen_dimensions_helper() {
+	stty cols 200
+	stty rows 50
+}
+
+last_save_file_differs_helper() {
+	local original_file="$1"
+	diff "$original_file" "${HOME}/.tmux/resurrect/last"
+	[ $? -ne 0 ]
+}

tests/run_tests_in_isolation

@@ -0,0 +1 @@
+../lib/tmux-test/tests/run_tests_in_isolation

tests/test_resurrect_restore.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source $CURRENT_DIR/helpers/helpers.sh
+source $CURRENT_DIR/helpers/resurrect_helpers.sh
+
+setup_before_restore() {
+	# setup restore file
+	mkdir -p ~/.tmux/resurrect/
+	cp tests/fixtures/restore_file.txt "${HOME}/.tmux/resurrect/restore_file.txt"
+	ln -sf restore_file.txt "${HOME}/.tmux/resurrect/last"
+
+	# directory used in restored tmux session
+	mkdir -p /tmp/bar
+}
+
+restore_tmux_environment_and_save_again() {
+	set_screen_dimensions_helper
+	$CURRENT_DIR/helpers/restore_and_save_tmux_test_environment.exp
+}
+
+main() {
+	install_tmux_plugin_under_test_helper
+	setup_before_restore
+	restore_tmux_environment_and_save_again
+
+	if last_save_file_differs_helper "tests/fixtures/restore_file.txt"; then
+		fail_helper "Saved file not correct after restore"
+	fi
+	exit_helper
+}
+main

tests/test_resurrect_save.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source $CURRENT_DIR/helpers/helpers.sh
+source $CURRENT_DIR/helpers/resurrect_helpers.sh
+
+create_tmux_test_environment_and_save() {
+	set_screen_dimensions_helper
+	$CURRENT_DIR/helpers/create_and_save_tmux_test_environment.exp
+}
+
+main() {
+	install_tmux_plugin_under_test_helper
+	mkdir -p /tmp/bar # setup required dirs
+	create_tmux_test_environment_and_save
+
+	if last_save_file_differs_helper "tests/fixtures/save_file.txt"; then
+		fail_helper "Saved file not correct (initial save)"
+	fi
+	exit_helper
+}
+main