initial

dot_tmux/plugins/tmux-continuum/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+### master
+- bugfix: "auto restore" feature stopped working
+- bugfix: prevent race condition when auto-saving with locks (@v9v)
+- Multiple users on a system can now each run continuum on their own.
+
+### v3.1.0, 2015-03-14
+- properly quote scripts
+- bugfix: "auto restore" feature does not work on tmux `1.9a`
+- bugfix: do not count `tmux source-file .tmux.conf` as a tmux process (when
+  checking if other tmux server is running). Previously, this caused
+  interpolation command not to be inserted into `status-right` because `tmux
+  source-file` was falsely detected as another tmux server.
+- add `#{continuum_status}` status line interpolation
+
+### v3.0.0, 2015-02-20
+- rename the plugin from `tmux-resurrect-auto` to `tmux-continuum`
+
+### v2.2.0, 2015-02-20
+- document tmux multi-server behavior in the readme
+- do not auto-restore tmux environment if another tmux server is already running
+  (we don't want to duplicate stuff)
+- bugfixes for 'tmux auto start' OS X Terminal.app and iTerm scripts
+- prevent saving for the first 15 minutes only when plugin is sourced the first
+  time (not on subsequent sources or tmux.conf reloads)
+- do not start auto-saving if there's another tmux server running (we don't want
+  for save files from various tmux environments to override each other)
+
+### v2.1.0, 2015-02-18
+- enable "tmux auto start" for OS X
+- enable customizing "tmux auto start" for OS X
+- fix errors when creating a launchd plist file for auto-start on OS X
+
+### v2.0.0, 2015-02-15
+- enable automatic environment restore when tmux is started
+
+### v1.0.0, 2015-02-12
+- first working version
+- run the save script in the background
+- do not start saving right after tmux is started
+- add a check for tmux version to the initializer script
+- when interval is set to '0' autosave is disabled
+- bugfix: helper files not loaded
+- update readme with the instructions how to disable auto saving

dot_tmux/plugins/tmux-continuum/CONTRIBUTING.md

@@ -0,0 +1,15 @@
+### Contributing
+
+Code contributions are welcome!
+
+If you wanna contribute a bigger feature, please open a github issue so we can
+discuss it together first.
+
+### Reporting a bug
+
+If you find a bug please report it in the issues. When reporting a bug please
+attach:
+- a file symlinked to `~/.tmux/resurrect/last`.
+- your `.tmux.conf`
+- if you're getting an error paste it to a [gist](https://gist.github.com/) and
+  link it in the issue

dot_tmux/plugins/tmux-continuum/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (C) Bruno Sutic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

dot_tmux/plugins/tmux-continuum/README.md

@@ -0,0 +1,103 @@
+# tmux-continuum
+
+Features:
+
+- continuous saving of tmux environment
+- automatic tmux start when computer/server is turned on
+- automatic restore when tmux is started
+
+Together, these features enable uninterrupted tmux usage. No matter the computer
+or server restarts, if the machine is on, tmux will be there how you left it off
+the last time it was used.
+
+Tested and working on Linux, OSX and Cygwin.
+
+#### Continuous saving
+
+Tmux environment will be saved at an interval of 15 minutes. All the saving
+happens in the background without impact to your workflow.
+
+This action starts automatically when the plugin is installed. Note it requires
+the status line to be `on` to run (since it uses a hook in status-right to run).
+
+#### Automatic tmux start
+
+Tmux is automatically started after the computer/server is turned on.
+
+See the [instructions](docs/automatic_start.md) on how to enable this for your
+system.
+
+#### Automatic restore
+
+Last saved environment is automatically restored when tmux is started.
+
+Put `set -g @continuum-restore 'on'` in `.tmux.conf` to enable this.
+
+Note: automatic restore happens **exclusively** on tmux server start. No other
+action (e.g. sourcing `.tmux.conf`) triggers this.
+
+#### Dependencies
+
+`tmux 1.9` or higher, `bash`,
+[tmux-resurrect](https://github.com/tmux-plugins/tmux-resurrect) plugin.
+
+### Installation with [Tmux Plugin Manager](https://github.com/tmux-plugins/tpm) (recommended)
+
+Please make sure you have
+[tmux-resurrect](https://github.com/tmux-plugins/tmux-resurrect) installed.
+
+Add plugin to the list of TPM plugins in `.tmux.conf`:
+
+    set -g @plugin 'tmux-plugins/tmux-resurrect'
+    set -g @plugin 'tmux-plugins/tmux-continuum'
+
+Hit `prefix + I` to fetch the plugin and source it. The plugin will
+automatically start "working" in the background, no action required.
+
+### Manual Installation
+
+Please make sure you have
+[tmux-resurrect](https://github.com/tmux-plugins/tmux-resurrect) installed.
+
+Clone the repo:
+
+    $ git clone https://github.com/tmux-plugins/tmux-continuum ~/clone/path
+
+Add this line to the bottom of `.tmux.conf`:
+
+    run-shell ~/clone/path/continuum.tmux
+
+Reload TMUX environment with: `$ tmux source-file ~/.tmux.conf`
+
+The plugin will automatically start "working" in the background, no action
+required.
+
+### Docs
+
+- [frequently asked questions](docs/faq.md)
+- [behavior when running multiple tmux servers](docs/multiple_tmux_servers.md) -
+  this doc is safe to skip, but you might want to read it if you're using tmux
+  with `-L` or `-S` flags
+- [automatically start tmux after the computer is turned on](docs/automatic_start.md)
+- [continuum status in tmux status line](docs/continuum_status.md)
+
+### Other goodies
+
+- [tmux-copycat](https://github.com/tmux-plugins/tmux-copycat) - a plugin for
+  regex searches in tmux and fast match selection
+- [tmux-yank](https://github.com/tmux-plugins/tmux-yank) - enables copying
+  highlighted text to system clipboard
+- [tmux-open](https://github.com/tmux-plugins/tmux-open) - a plugin for quickly
+  opening highlighted file or a url
+
+### Known Issues
+
+- In order to be executed periodically, the plugin updates the `status-right` tmux variable. In case some plugin (usually themes) overwrites the `status-right` variable, the autosave feature stops working. To fix this issue, place the plugin last in the TPM plugins list. 
+
+### Reporting bugs and contributing
+
+Both contributing and bug reports are welcome. Please check out
+[contributing guidelines](CONTRIBUTING.md).
+
+### License
+[MIT](LICENSE.md)

dot_tmux/plugins/tmux-continuum/docs/automatic_start.md

@@ -0,0 +1,47 @@
+# Automatic Tmux start
+
+Tmux is automatically started after the computer/server is turned on.
+
+### OS X
+
+To enable this feature:
+- put `set -g @continuum-boot 'on'` in `.tmux.conf`
+- reload tmux config with this shell command: `$ tmux source-file ~/.tmux.conf`
+
+Next time the computer is started:
+- `Terminal.app` window will open and resize to maximum size
+- `tmux` command will be executed in the terminal window
+- if "auto restore" feature is enabled, tmux will start restoring previous env
+
+Config options:
+- `set -g @continuum-boot-options 'fullscreen'` - terminal window
+  will go fullscreen
+- `set -g @continuum-boot-options 'iterm'` - start [iTerm](https://www.iterm2.com) instead
+  of `Terminal.app`
+- `set -g @continuum-boot-options 'iterm,fullscreen'` - start `iTerm`
+  in fullscreen
+- `set -g @continuum-boot-options 'kitty'` - start [kitty](https://sw.kovidgoyal.net/kitty) instead
+  of `Terminal.app`
+- `set -g @continuum-boot-options 'kitty,fullscreen'` - start `kitty`
+  in fullscreen
+- `set -g @continuum-boot-options 'alacritty'` - start [alacritty](https://github.com/alacritty/alacritty) instead of `Terminal.app`
+- `set -g @continuum-boot-options 'alacritty,fullscreen'` - start `alacritty`
+  in fullscreen
+
+Note: The first time you reboot your machine and activate this feature you may be prompted about a script requiring
+access to a system program (i.e. - System Events). If this happens tmux will not start automatically and you will need
+to go to `System Preferences -> Security & Privacy -> Accessability` and add the script to the list of apps that are
+allowed to control your computer.
+
+### Linux
+
+Help with this would be greatly appreciated. Please get in touch.
+
+#### Systemd
+
+##### this will only start the tmux server, it will *not* start any terminal emulator
+
+To enable automatic start with systemd:
+- Put `set -g @continuum-boot 'on'` in `.tmux.conf`
+- reload tmux config with this shell command: `$ tmux source-file ~/.tmux.conf`
+- see [systemd](/docs/systemd_details.md) for more details about how this is implemented

dot_tmux/plugins/tmux-continuum/docs/continuum_status.md

@@ -0,0 +1,17 @@
+## Continuum status in tmux status line
+
+There is an option to display current status of tmux continuum in tmux status
+line. This is done via `#{continuum_status}` interpolation and it works with
+both `status-right` and `status-left` tmux native options.
+
+Example usage:
+
+    set -g status-right 'Continuum status: #{continuum_status}'
+
+When running, `#{continuum_status}` will show continuum save interval:
+
+    Continuum status: 15
+
+or if continuous saving is disabled:
+
+    Continuum status: off

dot_tmux/plugins/tmux-continuum/docs/faq.md

@@ -0,0 +1,45 @@
+### FAQ
+
+> Will a previous save be overwritten immediately after I start tmux?
+
+No, first automatic save starts 15 minutes after tmux is started. If automatic
+restore is not enabled, that gives you enough time to manually restore from a
+previous save.
+
+> I want to make a restore to a previous point in time, but it seems that save
+is now overwritten?
+
+Read how to [restore a previously saved environment](https://github.com/tmux-plugins/tmux-resurrect/blob/master/docs/restoring_previously_saved_environment.md)
+
+> Will this plugin fill my hard disk?
+
+Most likely no. A regular save file is in the range of 5Kb. And `tmux-resurrect` already has a `remove_old_backups()` routine that will ["remove resurrect files older than 30 days, but keep at least 5 copies of backup."](https://github.com/tmux-plugins/tmux-resurrect/blob/da1a7558024b8552f7262b39ed22e3d679304f99/scripts/save.sh#L271-L277)
+
+> How do I change the save interval to i.e. 1 hour?
+
+The interval is always measured in minutes. So setting the interval to `60`
+(minutes) will do the trick. Put this in `.tmux.conf`:
+
+    set -g @continuum-save-interval '60'
+
+and then source `tmux.conf` by executing this command in the shell
+`$ tmux source-file ~/.tmux.conf`.
+
+> How do I stop automatic saving?
+
+Just set the save interval to `0`. Put this in `.tmux.conf`
+
+    set -g @continuum-save-interval '0'
+
+and then source `tmux.conf` by executing this command in the shell
+`$ tmux source-file ~/.tmux.conf`.
+
+> I had automatic restore turned on, how do I disable it now?
+
+Just remove `set -g @continuum-restore 'on'` from `tmux.conf`.
+
+To be absolutely sure automatic restore doesn't happen, create a
+`tmux_no_auto_restore` file in your home directory (command:
+`$ touch ~/tmux_no_auto_restore`). Automatic restore won't happen if this file
+exists.
+

dot_tmux/plugins/tmux-continuum/docs/multiple_tmux_servers.md

@@ -0,0 +1,20 @@
+### Behavior when running multiple tmux servers
+
+(This is safe to skip if you're always running a single tmux server.)
+
+If you're an advanced tmux user, you might be running multiple tmux servers at
+the same time. Maybe you start the first tmux server with `$ tmux` and then
+later another one with e.g. `$ tmux -S/tmp/foo`.
+
+You probably don't want to "auto restore" the same environment in the second
+tmux that uses `/tmp/foo` socket. You also probably don't want two tmux
+environments both having "auto save" feature on (think about overwrites).
+
+This plugin handles multi-server scenario by giving precedence to the tmux
+server that was first started.
+
+In the above example, the server started with `$ tmux` will do "auto
+restore" (if enabled) and will start "auto saving".
+"Auto restore" or "auto saving" **will not** happen for the second server that
+was started later with the `$ tmux -S/tmp/foo` command. The plugin will
+detect the presence of another server (`$ tmux`) and give it precedence.

dot_tmux/plugins/tmux-continuum/docs/systemd_details.md

@@ -0,0 +1,13 @@
+# Systemd automatic start for tmux
+
+The first time tmux starts when `@continuum-boot` is set to 'on' tmux-continuum will generate a user level systemd unit file which it will save to `${HOME}/.config/systemd/user/tmux.service` and enable it. From then on when that user logs in, either through a GUI session or on the console or via ssh, Systemd will start the tmux server.
+
+The command used to start the tmux server is determined via the `@continuum-systemd-start-cmd` option that can be set in .tmux.conf. (Remember to reload your configuration with `tmux source ~/.tmux.conf` afterwards.
+
+The default command to use is `new-session -d`. If you want more control over what sessions get started then you should set up your sessions in tmux.conf and set `@continuum-systemd-start-cmd = 'start-server'`. As this will be executed as part of systemd's ExecStart statement there will be no shell parsing. See [Systemd manual](http://www.freedesktop.org/software/systemd/man/systemd.service.html#Command%20lines) for more details.
+
+To control the tmux service you can use all the standard `systemctl` commands using the `--user` argument. eg to see if the tmux server has started:
+
+  systemctl --user status tmux.service
+
+

dot_tmux/plugins/tmux-continuum/dot_git/FETCH_HEAD

@@ -0,0 +1 @@
+0698e8f4b17d6454c71bf5212895ec055c578da0		branch 'master' of https://github.com/tmux-plugins/tmux-continuum

dot_tmux/plugins/tmux-continuum/dot_git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

dot_tmux/plugins/tmux-continuum/dot_git/ORIG_HEAD

@@ -0,0 +1 @@
+0698e8f4b17d6454c71bf5212895ec055c578da0

dot_tmux/plugins/tmux-continuum/dot_git/config

@@ -0,0 +1,13 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[submodule]
+	active = .
+[remote "origin"]
+	url = https://git::@github.com/tmux-plugins/tmux-continuum
+	fetch = +refs/heads/master:refs/remotes/origin/master
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master

dot_tmux/plugins/tmux-continuum/dot_git/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_commit-msg.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_fsmonitor-watchman.sample

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-push.sample

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-rebase.sample

@@ -0,0 +1,169 @@
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_pre-receive.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to make use of push options.
+# The example simply echoes all push options that start with 'echoback='
+# and rejects all pushes when the "reject" push option is used.
+#
+# To enable this hook, rename this file to "pre-receive".
+
+if test -n "$GIT_PUSH_OPTION_COUNT"
+then
+	i=0
+	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
+	do
+		eval "value=\$GIT_PUSH_OPTION_$i"
+		case "$value" in
+		echoback=*)
+			echo "echo from the pre-receive-hook: ${value#*=}" >&2
+			;;
+		reject)
+			exit 1
+		esac
+		i=$((i + 1))
+	done
+fi

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_prepare-commit-msg.sample

@@ -0,0 +1,42 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_push-to-checkout.sample

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

dot_tmux/plugins/tmux-continuum/dot_git/hooks/executable_update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

dot_tmux/plugins/tmux-continuum/dot_git/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

dot_tmux/plugins/tmux-continuum/dot_git/logs/HEAD

@@ -0,0 +1,2 @@
+0000000000000000000000000000000000000000 3e4bc35da41f956c873aea716c97555bf1afce5d wizard <wizard@devvm.(none)> 1678899277 +0000	clone: from https://github.com/tmux-plugins/tmux-continuum
+3e4bc35da41f956c873aea716c97555bf1afce5d 0698e8f4b17d6454c71bf5212895ec055c578da0 Viktor Barzin <vbarzin@gmail.com> 1713616989 +0000	pull: Fast-forward

dot_tmux/plugins/tmux-continuum/dot_git/logs/refs/heads/master

@@ -0,0 +1,2 @@
+0000000000000000000000000000000000000000 3e4bc35da41f956c873aea716c97555bf1afce5d wizard <wizard@devvm.(none)> 1678899277 +0000	clone: from https://github.com/tmux-plugins/tmux-continuum
+3e4bc35da41f956c873aea716c97555bf1afce5d 0698e8f4b17d6454c71bf5212895ec055c578da0 Viktor Barzin <vbarzin@gmail.com> 1713616989 +0000	pull: Fast-forward

dot_tmux/plugins/tmux-continuum/dot_git/logs/refs/remotes/origin/HEAD

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 3e4bc35da41f956c873aea716c97555bf1afce5d wizard <wizard@devvm.(none)> 1678899277 +0000	clone: from https://github.com/tmux-plugins/tmux-continuum

dot_tmux/plugins/tmux-continuum/dot_git/logs/refs/remotes/origin/master

@@ -0,0 +1 @@
+3e4bc35da41f956c873aea716c97555bf1afce5d 0698e8f4b17d6454c71bf5212895ec055c578da0 Viktor Barzin <vbarzin@gmail.com> 1713616988 +0000	pull: fast-forward

dot_tmux/plugins/tmux-continuum/dot_git/packed-refs

@@ -0,0 +1,2 @@
+# pack-refs with: peeled fully-peeled sorted 
+3e4bc35da41f956c873aea716c97555bf1afce5d refs/remotes/origin/master

dot_tmux/plugins/tmux-continuum/dot_git/refs/heads/master

@@ -0,0 +1 @@
+0698e8f4b17d6454c71bf5212895ec055c578da0

dot_tmux/plugins/tmux-continuum/dot_git/refs/remotes/origin/HEAD

@@ -0,0 +1 @@
+ref: refs/remotes/origin/master

dot_tmux/plugins/tmux-continuum/dot_git/refs/remotes/origin/master

@@ -0,0 +1 @@
+0698e8f4b17d6454c71bf5212895ec055c578da0

dot_tmux/plugins/tmux-continuum/dot_git/shallow

@@ -0,0 +1 @@
+3e4bc35da41f956c873aea716c97555bf1afce5d

dot_tmux/plugins/tmux-continuum/dot_gitattributes

@@ -0,0 +1,2 @@
+# Force text files to have unix eols, so Windows/Cygwin does not break them
+*.* eol=lf

dot_tmux/plugins/tmux-continuum/executable_continuum.tmux

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+set -x
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/scripts/helpers.sh"
+source "$CURRENT_DIR/scripts/variables.sh"
+source "$CURRENT_DIR/scripts/shared.sh"
+
+save_command_interpolation="#($CURRENT_DIR/scripts/continuum_save.sh)"
+
+supported_tmux_version_ok() {
+	"$CURRENT_DIR/scripts/check_tmux_version.sh" "$SUPPORTED_VERSION"
+}
+
+handle_tmux_automatic_start() {
+	"$CURRENT_DIR/scripts/handle_tmux_automatic_start.sh"
+}
+
+another_tmux_server_running() {
+	if just_started_tmux_server; then
+		another_tmux_server_running_on_startup
+	else
+		# script loaded after tmux server start can have multiple clients attached
+		[ "$(number_tmux_processes_except_current_server)" -gt "$(number_current_server_client_processes)" ]
+	fi
+}
+
+delay_saving_environment_on_first_plugin_load() {
+	if [ -z "$(get_tmux_option "$last_auto_save_option" "")" ]; then
+		# last save option not set, this is first time plugin load
+		set_last_save_timestamp
+	fi
+}
+
+add_resurrect_save_interpolation() {
+	local status_right_value="$(get_tmux_option "status-right" "")"
+	# check interpolation not already added
+	if ! [[ "$status_right_value" == *"$save_command_interpolation"* ]]; then
+		local new_value="${save_command_interpolation}${status_right_value}"
+		set_tmux_option "status-right" "$new_value"
+	fi
+}
+
+just_started_tmux_server() {
+	local tmux_start_time
+	tmux_start_time="$(tmux display-message -p -F '#{start_time}')"
+	local restore_max_delay
+	restore_max_delay="$(get_tmux_option "$auto_restore_max_delay_option" "${auto_restore_max_delay_default}")"
+	[ "$tmux_start_time" == "" ] || [ "$tmux_start_time" -gt "$(($(date +%s)-${restore_max_delay}))" ]
+}
+
+start_auto_restore_in_background() {
+	"$CURRENT_DIR/scripts/continuum_restore.sh" &
+}
+
+update_tmux_option() {
+	local option="$1"
+	local option_value="$(get_tmux_option "$option")"
+	# replace interpolation string with a script to execute
+	local new_option_value="${option_value/$status_interpolation_string/$status_script}"
+	set_tmux_option "$option" "$new_option_value"
+}
+
+main() {
+	if supported_tmux_version_ok; then
+		handle_tmux_automatic_start
+
+		# Advanced edge case handling: start auto-saving only if this is the
+		# only tmux server. We don't want saved files from more environments to
+		# overwrite each other.
+		if ! another_tmux_server_running; then
+			# give user a chance to restore previously saved session
+			delay_saving_environment_on_first_plugin_load
+			add_resurrect_save_interpolation
+		fi
+
+		if just_started_tmux_server; then
+			start_auto_restore_in_background
+		fi
+
+		# Put "#{continuum_status}" interpolation in status-right or
+		# status-left tmux option to get current tmux continuum status.
+		update_tmux_option "status-right"
+		update_tmux_option "status-left"
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/executable_check_tmux_version.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+VERSION="$1"
+UNSUPPORTED_MSG="$2"
+
+# this is used to get "clean" integer version number. Examples:
+# `tmux 1.9` => `19`
+# `1.9a`     => `19`
+get_digits_from_string() {
+	local string="$1"
+	local only_digits="$(echo "$string" | tr -dC '[:digit:]')"
+	echo "$only_digits"
+}
+
+tmux_version_int() {
+	local tmux_version_string=$(tmux -V)
+	echo "$(get_digits_from_string "$tmux_version_string")"
+}
+
+exit_if_unsupported_version() {
+	local current_version="$1"
+	local supported_version="$2"
+	if [ "$current_version" -lt "$supported_version" ]; then
+		exit 1
+	fi
+}
+
+main() {
+	local supported_version_int="$(get_digits_from_string "$VERSION")"
+	local current_version_int="$(tmux_version_int)"
+	exit_if_unsupported_version "$current_version_int" "$supported_version_int"
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/executable_continuum_restore.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/helpers.sh"
+source "$CURRENT_DIR/variables.sh"
+
+auto_restore_enabled() {
+	local auto_restore_value="$(get_tmux_option "$auto_restore_option" "$auto_restore_default")"
+	[ "$auto_restore_value" == "on" ] && [ ! -f "$auto_restore_halt_file" ]
+}
+
+fetch_and_run_tmux_resurrect_restore_script() {
+	# give tmux some time to start and source all the plugins
+	sleep 1
+	local resurrect_restore_script_path="$(get_tmux_option "$resurrect_restore_path_option" "")"
+	if [ -n "$resurrect_restore_script_path" ]; then
+		"$resurrect_restore_script_path"
+	fi
+}
+
+main() {
+	# Advanced edge case handling: auto restore only if this is the only tmux
+	# server. If another tmux server exists, it is assumed auto-restore is not wanted.
+	if auto_restore_enabled && ! another_tmux_server_running_on_startup; then
+		fetch_and_run_tmux_resurrect_restore_script
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/executable_continuum_save.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/helpers.sh"
+source "$CURRENT_DIR/variables.sh"
+source "$CURRENT_DIR/shared.sh"
+
+supported_tmux_version_ok() {
+	"$CURRENT_DIR/check_tmux_version.sh" "$SUPPORTED_VERSION"
+}
+
+get_interval() {
+	get_tmux_option "$auto_save_interval_option" "$auto_save_interval_default"
+}
+
+auto_save_not_disabled() {
+	[ "$(get_interval)" -gt 0 ]
+}
+
+enough_time_since_last_run_passed() {
+	local last_saved_timestamp="$(get_tmux_option "$last_auto_save_option" "0")"
+	local interval_minutes="$(get_interval)"
+	local interval_seconds="$((interval_minutes * 60))"
+	local next_run="$((last_saved_timestamp + $interval_seconds))"
+	[ "$(current_timestamp)" -ge "$next_run" ]
+}
+
+fetch_and_run_tmux_resurrect_save_script() {
+	local resurrect_save_script_path="$(get_tmux_option "$resurrect_save_path_option" "")"
+	if [ -n "$resurrect_save_script_path" ]; then
+		"$resurrect_save_script_path" "quiet" >/dev/null 2>&1 &
+		set_last_save_timestamp
+	fi
+}
+
+acquire_lock() {
+	# Sometimes tmux starts multiple saves in parallel. We want only one
+	# save to be running, otherwise we can get corrupted saved state.
+	local lockdir_prefix="/tmp/tmux-continuum-$(current_tmux_server_pid)-lock-"
+	# The following implements a lock that auto-expires after 100...200s.
+	local lock_generation=$((`date +%s` / 100))
+	local lockdir1="${lockdir_prefix}${lock_generation}"
+	local lockdir2="${lockdir_prefix}$(($lock_generation + 1))"
+	if mkdir "$lockdir1"; then
+		trap "rmdir "$lockdir1"" EXIT
+		if mkdir "$lockdir2"; then
+			trap "rmdir "$lockdir1" "$lockdir2"" EXIT
+			return 0
+		fi
+	fi
+	return 1  # Someone else has the lock.
+}
+
+main() {
+	if supported_tmux_version_ok && auto_save_not_disabled && enough_time_since_last_run_passed && acquire_lock; then
+		fetch_and_run_tmux_resurrect_save_script
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/executable_continuum_status.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/helpers.sh"
+source "$CURRENT_DIR/variables.sh"
+
+print_status() {
+	local save_int="$(get_tmux_option "$auto_save_interval_option")"
+	local status=""
+	local style_wrap
+	if [ $save_int -gt 0 ]; then
+		style_wrap="$(get_tmux_option "$status_on_style_wrap_option" "")"
+		status="$save_int"
+	else
+		style_wrap="$(get_tmux_option "$status_off_style_wrap_option" "")"
+		status="off"
+	fi
+
+	if [ -n "$style_wrap" ]; then
+		status="${style_wrap/$status_wrap_string/$status}"
+	fi
+	echo "$status"
+}
+print_status

dot_tmux/plugins/tmux-continuum/scripts/executable_handle_tmux_automatic_start.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/helpers.sh"
+source "$CURRENT_DIR/variables.sh"
+
+is_tmux_automatic_start_enabled() {
+	local auto_start_value="$(get_tmux_option "$auto_start_option" "$auto_start_default")"
+	[ "$auto_start_value" == "on" ]
+}
+
+is_osx() {
+	[ $(uname) == "Darwin" ]
+}
+
+is_systemd() {
+	[ $(ps -o comm= -p1) == 'systemd' ]
+}
+
+main() {
+	if is_tmux_automatic_start_enabled; then
+		if is_osx; then
+			"$CURRENT_DIR/handle_tmux_automatic_start/osx_enable.sh"
+		elif is_systemd; then
+			"$CURRENT_DIR/handle_tmux_automatic_start/systemd_enable.sh"
+		fi
+	else
+		if is_osx; then
+			"$CURRENT_DIR/handle_tmux_automatic_start/osx_disable.sh"
+		elif is_systemd; then
+			"$CURRENT_DIR/handle_tmux_automatic_start/systemd_disable.sh"
+		fi
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_alacritty_start_tmux.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+# for "true full screen" call the script with "fullscreen" as the first argument
+TRUE_FULL_SCREEN="$1"
+
+start_terminal_and_run_tmux() {
+	osascript <<-EOF
+	tell application "alacritty"
+		activate
+		delay 0.5
+		tell application "System Events" to tell process "alacritty"
+			set frontmost to true
+			keystroke "tmux"
+			key code 36
+		end tell
+	end tell
+	EOF
+}
+
+resize_window_to_full_screen() {
+	osascript <<-EOF
+	tell application "alacritty"
+		activate
+		tell application "System Events"
+			if (every window of process "alacritty") is {} then
+				keystroke "n" using command down
+			end if
+
+			tell application "Finder"
+				set desktopSize to bounds of window of desktop
+			end tell
+
+			set position of front window of process "alacritty" to {0, 0}
+			set size of front window of process "alacritty" to {item 3 of desktopSize, item 4 of desktopSize}
+		end tell
+	end tell
+	EOF
+}
+
+resize_to_true_full_screen() {
+	osascript <<-EOF
+	tell application "Alacritty"
+		activate
+		delay 0.5
+		tell application "System Events" to tell process "Alacritty"
+			if front window exists then
+				tell front window
+					if value of attribute "AXFullScreen" then
+						set value of attribute "AXFullScreen" to false
+					else
+						set value of attribute "AXFullScreen" to true
+					end if
+				end tell
+			end if
+		end tell
+	end tell
+	EOF
+}
+
+main() {
+	start_terminal_and_run_tmux
+	if [ "$TRUE_FULL_SCREEN" == "fullscreen" ]; then
+		resize_to_true_full_screen
+	else
+		resize_window_to_full_screen
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_disable.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/../variables.sh"
+
+main() {
+	rm "$osx_auto_start_file_path" > /dev/null 2>&1
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_enable.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/../helpers.sh"
+source "$CURRENT_DIR/../variables.sh"
+
+template() {
+	local tmux_start_script="$1"
+	local is_fullscreen="$2"
+
+	local fullscreen_tag=""
+	if [ "$is_fullscreen" == "true" ]; then
+		# newline and spacing so tag is aligned with other tags in template
+		fullscreen_tag=$'\n        <string>fullscreen</string>'
+	fi
+
+	local content
+	read -r -d '' content <<-EOF
+	<?xml version="1.0" encoding="UTF-8"?>
+	<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+	<plist version="1.0">
+	<dict>
+	    <key>Label</key>
+	    <string>${osx_auto_start_file_name}</string>
+	    <key>ProgramArguments</key>
+	    <array>
+	        <string>${tmux_start_script}</string>$fullscreen_tag
+	    </array>
+	    <key>RunAtLoad</key>
+	    <true/>
+	</dict>
+	</plist>
+	EOF
+	echo "$content"
+}
+
+get_strategy() {
+	local options="$1"
+	if [[ "$options" =~ "iterm" ]]; then
+		echo "iterm"
+	elif [[ "$options" =~ "kitty" ]]; then
+		echo "kitty"
+	elif [[ "$options" =~ "alacritty" ]]; then
+		echo "alacritty"
+	else
+		# Terminal.app is the default console app
+		echo "terminal"
+	fi
+}
+
+get_fullscreen_option_value() {
+	local options="$1"
+	if [[ "$options" =~ "fullscreen" ]]; then
+		echo "true"
+	else
+		echo "false"
+	fi
+}
+
+main() {
+	local options="$(get_tmux_option "$auto_start_config_option" "$auto_start_config_default")"
+	local strategy="$(get_strategy "$options")"
+	local fullscreen_option_value="$(get_fullscreen_option_value "$options")"
+	local tmux_start_script_path="${CURRENT_DIR}/osx_${strategy}_start_tmux.sh"
+
+	local launchd_plist_file_content="$(template "$tmux_start_script_path" "$fullscreen_option_value")"
+	if ! diff "$osx_auto_start_file_path" <(echo "$launchd_plist_file_content") &>/dev/null ; then
+		echo "$launchd_plist_file_content" > "$osx_auto_start_file_path"
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_iterm_start_tmux.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+# for "true full screen" call the script with "fullscreen" as the first argument
+TRUE_FULL_SCREEN="$1"
+
+start_iterm_and_run_tmux() {
+	osascript <<-EOF
+	tell application "iTerm"
+		activate
+
+		# open iterm window
+		try
+			set _session to current session of current window
+		on error
+			set _term to (make new terminal)
+			tell _term
+				launch session "Tmux"
+				set _session to current session
+			end tell
+		end try
+
+		# start tmux
+		tell _session
+			write text "tmux"
+		end tell
+	end tell
+	EOF
+}
+
+resize_window_to_full_screen() {
+	osascript <<-EOF
+	tell application "iTerm"
+		set winID to id of window 1
+		tell application "Finder"
+			set desktopSize to bounds of window of desktop
+		end tell
+		set bounds of window id winID to desktopSize
+	end tell
+	EOF
+}
+
+resize_to_true_full_screen() {
+	osascript <<-EOF
+	tell application "iTerm"
+		# wait for iTerm to start
+		delay 1
+		activate
+		# short wait for iTerm to gain focus
+		delay 0.1
+		# Command + Enter for fullscreen
+		tell application "System Events"
+			key code 36 using {command down}
+		end tell
+	end tell
+	EOF
+}
+
+main() {
+	start_iterm_and_run_tmux
+	if [ "$TRUE_FULL_SCREEN" == "fullscreen" ]; then
+		resize_to_true_full_screen
+	else
+		resize_window_to_full_screen
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_kitty_start_tmux.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+# for "true full screen" call the script with "fullscreen" as the first argument
+TRUE_FULL_SCREEN="$1"
+
+start_terminal_and_run_tmux() {
+	osascript <<-EOF
+	tell application "kitty"
+		activate
+		delay 5
+		tell application "System Events" to tell process "kitty"
+			set frontmost to true
+			keystroke "tmux"
+			key code 36
+		end tell
+	end tell
+	EOF
+}
+
+resize_window_to_full_screen() {
+	osascript <<-EOF
+	tell application "kitty"
+		activate
+		tell application "System Events"
+			if (every window of process "kitty") is {} then
+				keystroke "n" using command down
+			end if
+
+			tell application "Finder"
+				set desktopSize to bounds of window of desktop
+			end tell
+
+			set position of front window of process "kitty" to {0, 0}
+			set size of front window of process "kitty" to {item 3 of desktopSize, item 4 of desktopSize}
+		end tell
+	end tell
+	EOF
+}
+
+resize_to_true_full_screen() {
+	osascript <<-EOF
+	tell application "kitty"
+		activate
+		delay 1
+		tell application "System Events" to tell process "kitty"
+			keystroke "f" using {control down, command down}
+		end tell
+	end tell
+	EOF
+}
+
+main() {
+	start_terminal_and_run_tmux
+	if [ "$TRUE_FULL_SCREEN" == "fullscreen" ]; then
+		resize_to_true_full_screen
+	else
+		resize_window_to_full_screen
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_osx_terminal_start_tmux.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+# for "true full screen" call the script with "fullscreen" as the first argument
+TRUE_FULL_SCREEN="$1"
+
+start_terminal_and_run_tmux() {
+	osascript <<-EOF
+	tell application "Terminal"
+		if not (exists window 1) then reopen
+		activate
+		set winID to id of window 1
+		do script "tmux" in window id winID
+	end tell
+	EOF
+}
+
+resize_window_to_full_screen() {
+	osascript <<-EOF
+	tell application "Terminal"
+		set winID to id of window 1
+		tell application "Finder"
+			set desktopSize to bounds of window of desktop
+		end tell
+		set bounds of window id winID to desktopSize
+	end tell
+	EOF
+}
+
+resize_to_true_full_screen() {
+	osascript <<-EOF
+	tell application "Terminal"
+		# waiting for Terminal.app to start
+		delay 1
+		activate
+		# short wait for Terminal to gain focus
+		delay 0.1
+		tell application "System Events"
+			keystroke "f" using {control down, command down}
+		end tell
+	end tell
+	EOF
+}
+
+main() {
+	start_terminal_and_run_tmux
+	if [ "$TRUE_FULL_SCREEN" == "fullscreen" ]; then
+		resize_to_true_full_screen
+	else
+		resize_window_to_full_screen
+	fi
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_systemd_disable.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+# Maintainer: Sven Vowe @nuclearglow
+# Contact maintainer for any change to this file.
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/../variables.sh"
+
+main() {
+	systemctl --user disable ${systemd_service_name}
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/executable_systemd_enable.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+
+# Maintainer: Sven Vowe @nuclearglow
+# Contact maintainer for any change to this file.
+
+CURRENT_DIR="$( dirname ${BASH_SOURCE[0]} )"
+
+source "$CURRENT_DIR/../helpers.sh"
+source "$CURRENT_DIR/../variables.sh"
+
+template() {
+	local tmux_start_script="$1"
+	shift
+	local options="$@"
+	local content=""
+	local resurrect_save_script_path="$(get_tmux_option "$resurrect_save_path_option" "$(realpath ${CURRENT_DIR}/../../../tmux-resurrect/scripts/save.sh)")"
+	local tmux_path="$(command -v tmux)"
+
+	read -r -d '' content <<-EOF
+	[Unit]
+	Description=tmux default session (detached)
+	Documentation=man:tmux(1)
+
+	[Service]
+	Type=forking
+	Environment=DISPLAY=:0
+	ExecStart=${tmux_path} ${systemd_tmux_server_start_cmd}
+
+	ExecStop=${resurrect_save_script_path}
+	ExecStop=${tmux_path} kill-server
+	KillMode=control-group
+
+	RestartSec=2
+
+	[Install]
+	WantedBy=default.target
+	EOF
+
+	echo "$content"
+}
+
+systemd_tmux_is_enabled() {
+	systemctl --user is-enabled $(basename "${systemd_unit_file_path}") >/dev/null 2>&1
+}
+
+enable_tmux_unit_on_boot() {
+	if ! systemd_tmux_is_enabled; then
+		systemctl --user enable ${systemd_service_name}
+	fi
+}
+
+systemd_unit_file() {
+	local options="$(get_tmux_option "$auto_start_config_option" "${auto_start_config_default}")"
+	local systemd_tmux_server_start_cmd="$(get_tmux_option "${systemd_tmux_server_start_cmd_option}" "${systemd_tmux_server_start_cmd_default}" )"
+	local tmux_start_script_path="${CURRENT_DIR}/linux_start_tmux.sh"
+	local systemd_unit_file=$(template "${tmux_start_script_path}" "${options}")
+	echo "$systemd_unit_file"
+}
+
+write_unit_file() {
+	systemd_unit_file > "${systemd_unit_file_path}"
+}
+
+write_unit_file_unless_exists() {
+	local systemd_unit_file_dir=$(dirname ${systemd_unit_file_path})
+	if ! [ -d $systemd_unit_file_dir ]; then
+		mkdir -p $systemd_unit_file_dir
+		write_unit_file
+	elif ! [ -e "${systemd_unit_file_path}" ]; then
+		write_unit_file
+	fi
+}
+
+main() {
+	write_unit_file_unless_exists
+	enable_tmux_unit_on_boot
+}
+main

dot_tmux/plugins/tmux-continuum/scripts/handle_tmux_automatic_start/symlink_README.md

@@ -0,0 +1 @@
+../../docs/automatic_start.md

dot_tmux/plugins/tmux-continuum/scripts/helpers.sh

@@ -0,0 +1,49 @@
+get_tmux_option() {
+	local option="$1"
+	local default_value="$2"
+	local option_value=$(tmux show-option -gqv "$option")
+	if [ -z "$option_value" ]; then
+		echo "$default_value"
+	else
+		echo "$option_value"
+	fi
+}
+
+set_tmux_option() {
+	local option="$1"
+	local value="$2"
+	tmux set-option -gq "$option" "$value"
+}
+
+# multiple tmux server detection helpers
+
+current_tmux_server_pid() {
+	echo "$TMUX" |
+		cut -f2 -d","
+}
+
+all_tmux_processes() {
+	# ignores `tmux source-file .tmux.conf` command used to reload tmux.conf
+	local user_id=$(id -u)
+	ps -u $user_id -o "command pid" |
+		\grep "^tmux" |
+		\grep -v "^tmux source"
+}
+
+number_tmux_processes_except_current_server() {
+	all_tmux_processes |
+		\grep -v " $(current_tmux_server_pid)$" |
+		wc -l |
+		sed "s/ //g"
+}
+
+number_current_server_client_processes() {
+	tmux list-clients |
+		wc -l |
+		sed "s/ //g"
+}
+
+another_tmux_server_running_on_startup() {
+	# there are 2 tmux processes (current tmux server + 1) on tmux startup
+	[ "$(number_tmux_processes_except_current_server)" -gt 1 ]
+}

dot_tmux/plugins/tmux-continuum/scripts/shared.sh

@@ -0,0 +1,7 @@
+current_timestamp() {
+	echo "$(date +%s)"
+}
+
+set_last_save_timestamp() {
+	set_tmux_option "$last_auto_save_option" "$(current_timestamp)"
+}

dot_tmux/plugins/tmux-continuum/scripts/variables.sh

@@ -0,0 +1,43 @@
+SUPPORTED_VERSION="1.9"
+
+# these tmux options contain paths to tmux resurrect save and restore scripts
+resurrect_save_path_option="@resurrect-save-script-path"
+resurrect_restore_path_option="@resurrect-restore-script-path"
+
+auto_save_interval_option="@continuum-save-interval"
+auto_save_interval_default="15"
+
+# time when the tmux environment was last saved (unix timestamp)
+last_auto_save_option="@continuum-save-last-timestamp"
+
+auto_restore_option="@continuum-restore"
+auto_restore_default="off"
+
+auto_restore_halt_file="${HOME}/tmux_no_auto_restore"
+
+auto_restore_max_delay_option="@continuum-restore-max-delay"
+auto_restore_max_delay_default="10"
+
+# tmux auto start options
+auto_start_option="@continuum-boot"
+auto_start_default="off"
+
+# comma separated list of additional options for tmux auto start
+auto_start_config_option="@continuum-boot-options"
+auto_start_config_default=""
+
+osx_auto_start_file_name="Tmux.Start.plist"
+osx_auto_start_file_path="${HOME}/Library/LaunchAgents/${osx_auto_start_file_name}"
+
+status_interpolation_string="\#{continuum_status}"
+status_script="#($CURRENT_DIR/scripts/continuum_status.sh)"
+# below options set style/color for #{continuum_status} interpolation
+status_on_style_wrap_option="@continuum-status-on-wrap-style"   # example value: "#[fg=green]#{value}#[fg=white]"
+status_off_style_wrap_option="@continuum-status-off-wrap-style" # example value: "#[fg=yellow,bold]#{value}#[fg=white,nobold]"
+status_wrap_string="\#{value}"
+
+systemd_service_name="tmux.service"
+systemd_unit_file_path="$HOME/.config/systemd/user/${systemd_service_name}"
+
+systemd_tmux_server_start_cmd_option="@continuum-systemd-start-cmd"
+systemd_tmux_server_start_cmd_default="new-session -d"