18 changed files with 294 additions and 1322 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,29 +1,15 @@
 [package]
 name = "remux"
-version = "0.4.0"
+version = "0.1.2"
 edition = "2021"
 authors = [ "Valerie Wolfe <sleeplessval@gmail.com>" ]
 description = "A friendly command shortener for tmux"
 homepage = "https://git.vwolfe.io/valerie/remux"
 repository = "https://git.vwolfe.io/valerie/remux"
 license = "MIT"
 categories = [ "command-line-utilities" ]
 keywords = [ "tmux", "remux" ]
-[package.metadata.aur]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 name = "remux"
 type = "source"
 archive = "archive/v$pkgver.tar.gz"
 depends = [ "tmux>=3.0" ]
 [[bin]]
 name = "remux"
 path = "src/main.rs"
 [dependencies]
 pico-args = { version = "0.5.0", features = [ "combined-flags", "eq-separator" ] }
 #ratatui = { version = "0.20.1", features = [ "termion" ] }
 termion = "2.0.1"
-tmux_interface = "0.3.2"
+tmux_interface = "0.2.1"
 [profile.release]
 opt-level = 's'
@ -31,5 +17,5 @@ lto = true
 debug = false
 codegen-units = 1
 panic = "abort"
-strip = "symbols"
+strip = "debuginfo"
--- a/19
+++ b/19
@ -1,19 +0,0 @@
 Copyright (c) 2024 Valerie Wolfe
 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.
--- a/README.md
+++ b/README.md
@ -7,111 +7,37 @@ A tmux wrapper and command shortener written in Rust. ReMux's
 goal is to wrap tmux commands to be both shorter, and oriented
 around session names instead of session IDs.
 To further simplify developer usage, the `attach`, `detach`, `has`, and `new`
 commands can be used without a target field, and will default to the name of
 the Git repository root directory, if one is found.
 In their shortest forms, *every* ReMux command is as short or
 shorter than its equivalent tmux command:
 ```sh
 #	new session
-tmux new-s -t foo
+tmux new-session -t foo
 remux n foo
-#	list sessions
+#	lists
 tmux ls
 remux l
 remux
 #	attach
 tmux a -t foo
 remux a foo
 #	has
-tmux h -t foo
+tmux has -t foo
-remux h foo
+remux has foo
 #	detach
-tmux det -t foo
+tmux detach-client -t foo
 remux d foo
 #	nesting sessions with '-n' flag
 TMUX='' tmux a -t foo
 remux a -n foo
 TMUX='' tmux new-session -t foo
 remux n -n foo
 #	switch to another session
 tmux swi -t foo
 rmux s foo
 #	cd to session path
 cd `tmux display-mes -p "#{session_path}"`
 cd `rmux p`
 ```
 ## Dependencies
 ReMux depends on [tmux](https://github.com/tmux/tmux).
 ## Installation
 ### Manual Install
 <details>
 <summary>Release Binary</summary>
 Copy the compiled binary from the <a href="https://git.vwolfe.io/valerie/remux/releases">releases page</a>
 to a directory in <code>$PATH</code>, such as <code>/usr/bin/</code>.
 </details>
 <details>
 <summary>Compile from Source</summary>
 Compile using cargo with the command <code>cargo build --release</code> and copy
 the file from <code>target/release/</code> to a directory in <code>$PATH</code>,
 such as <code>/usr/bin/</code>.
 </details>
 <details>
 <summary>makepkg (AUR)</summary>
 Clone the <a href="https://aur.archlinux.org/remux.git">AUR Repository</a> and
 run the command <code>makepkg --install</code>.
 </details>
 ### Package Managers
 <details>
 <summary>Arch Linux (AUR): <code>remux</code></summary>
 Install the package from the <a href="https://aur.archlinux.org/packages/remux"><code>remux</code> AUR Package</a>
 using an AUR package manager such as <a href="https://github.com/Morganamilo/paru"><code>paru</code></a>.
 </details>
 <details>
 <summary>Cargo: <code>tmux-remux</code></summary>
 Install the package using Cargo with the command <code>cargo install tmux-remux</code>.
 </details>
 ### Supplemental
 <details>
 <summary>Bash Completions</summary>
 Copy <code>bash-completion/remux</code> to the appropriate directory, typically
 <code>/usr/share/bash-completion</code>.
 </details>
 <details>
 <summary>Man Page: Section 1</summary>
 Copy <code>man/remux.1</code> into <code>/usr/share/man/man1/</code>.
 </details>
 ## Configuration
 The pretty-print attached symbol (default: `*`) can be set manually by setting `REMUX_ATTACH_SYMBOL`.
 ## Libraries
 - [pico-args](https://crates.io/crates/pico_args) — argument parsing
 - [termion](https://crates.io/crates/termion) — ANSI formatting
 - [tmux_interface](https://crates.io/crates/tmux_interface) — tmux communication
 - [termion](https://crates.io/crates/termion) — ANSI formatting
--- a/bash-completion/remux
+++ b/bash-completion/remux
@ -1,19 +0,0 @@
 _remux() {
 	local word
 	COMPREPLY=()
 	word="${COMP_WORDS[COMP_CWORD]}"
 	case $COMP_CWORD in
 	1)
 		COMPREPLY=( `compgen -W 'attach detach has help list new path switch title' -- "$word"` )
 		;;
 	2)
 		COMPREPLY=( `compgen -W "$(remux l -q $word)"` )
 		;;
 	esac
 	return 0
 }
 complete -F _remux remux
--- a/deny.toml
+++ b/deny.toml
@ -1,4 +0,0 @@
 [licenses]
 allow = [ "MIT" ]
--- a/man/remux.1
+++ b/man/remux.1
@ -1,179 +0,0 @@
 .Dd $Mdocdate$
 .Dt REMUX 1
 .Sh NAME
 .Nm remux
 .Nd a command shortener for
 .Xr tmux 1
 .Sh SYNOPSIS
 .Nm remux
 .Op Fl dhnqrtv
 .Op Fl D Ar path
 .Op Ar command
 .Op args...
 .Sh DESCRIPTION
 .Nm
 is a wrapper and command shortener for
 .Xr tmux 1 ,
 primarily focused on improving the ergonomics of using named sessions.
 .Pp
 If no command is provided, remux will use the context action. Inside a repository, remux will attach or create. If in a session or outside a repository, remux will list sessions.
 .Sh COMMANDS
 .Nm remux
 commands are split into two categories: global commands, which can be used anywhere, and session commands, which can only be used from inside a session.
 .Ss GLOBAL COMMANDS
 .Bl -tag -width Ds
 .It Xo Ic attach
 .Op Fl dnr
 .Op Ar title
 .Op Ar window
 .Xc
 .Bd -literal -compact
 aliases: a
 Attaches to an existing session.
 .Ed
 .Pp
 .Bl -tag -width Ds -compact
 .It Fl d , Fl -detach
 Detach all other connections to the session.
 .It Fl D , Fl -dir Ar path
 Sets the working directory for the given command.
 .It Fl n , Fl -nest
 Allow nesting (attaching a session from inside another session).
 .It Fl r , Fl -read-only
 Attach the session in read-only mode.
 .It Ar title
 The title of the target session. If not given, remux will try to use the name of the repository containing the current directory.
 .It Ar window
 The name of the window to attach to.
 .El
 .It Xo Ic detach
 .Op Ar title
 .Xc
 .Bd -literal -compact
 aliases: d
 Detaches all clients from the target session.
 .Ed
 .It Xo Ic has
 .Op Fl q
 .Op Ar title
 .Xc
 .Bd -literal -compact
 aliases: h
 Checks whether or not a session exists.
 .Ed
 .Pp
 .Bl -tag -width Ds -compact
 .It Fl q , Fl -quiet
 Run silently without printing to standard output.
 .It Ar title
 The title of the target session. If not given, remux will attempt to use the name of the repository containing the current directory.
 .El
 .It Ic list
 .Bd -literal -compact
 aliases: l, ls
 Pretty-prints a list of tmux sessions.
 .Ed
 .It Xo Ic new
 .Op Fl dn
 .Op Fl t\ |\ --target Ar path
 .Op Ar title
 .Op Ar command
 .Xc
 .Bd -literal -compact
 aliases: n
 Creates a new session.
 .Ed
 .Pp
 .Bl -tag -width Ds -compact
 .It Fl d , Fl -detach
 Creates the session without attaching.
 .It Fl n , Fl -nest
 Allow nesting (attaching a session from inside another session).
 .It Fl t , Fl -target Ar path
 Sets the session path to the provided directory.
 .It Ar title
 Create the session with the given title. If not given, remux will attempt to use the name of the repository containing the current directory.
 .El
 .El
 .Ss SESSION COMMANDS
 .Bl -tag -width Ds
 .It Ic path
 .Bd -literal -compact
 aliases: p
 Prints the session path.
 .Ed
 .It Xo Ic switch
 .Op Fl rd
 .Op Ar title
 .Xc
 .Bd -literal -compact
 aliases: s
 Switches from the current session to the target.
 .Ed
 .Pp
 .Bl -tag -width Ds -compact
 .It Fl d , Fl -detach
 Detaches other clients from the target session.
 .It Fl r , Fl -read-only
 Switch to the target session in read-only mode.
 .It Ar title
 The title of the session to switch to. If blank, the previous session will be used.
 .El
 .It Ic title
 .Bd -literal -compact
 aliases: t, which
 Prints the session title.
 .El
 .Sh ENVIRONMENT
 .Bl -tag -width Ds
 .It Ev REMUX_ATTACH_SYMBOL
 Changes the symbol displayed for attached sessions in the
 .Ic list
 command.
 Default: '*'
 .It Ev REMUX_CURRENT_SYMBOL
 Changes the symbol displayed for the current session in the
 .Ic list
 command.
 Default: '>'
 .It Ev REMUX_NEW_WINDOW
 Provides a default windows name when creating a new session. Unused if empty.
 Default: (unset)
 .It Ev REMUX_PREVIOUS_SYMBOL
 Changes the symbol displayed for the previous session in the
 .Ic list
 command.
 Default: '-'
 .It Ev REMUX_REPO_FILE
 The filename to match on when trying to find the root of a repository.
 Default: '.git'
 .El
 .Sh EXIT STATUS
 .Bl -tag -Width Ds
 .It 1
 Unmatched command name.
 .It 2
 Unmatched target session.
 .It 3
 Unmatched help topic.
 .It 4
 Missing or invalid target; target was not given or is the same as the current session.
 .It 5
 .Nm remux
 is not running from within a terminal.
 .It 6
 Nesting error; nest flag is missing or inappropriate.
 .It 7
 A session command was attempted outside a session.
 .Sh EXAMPLES
 Use
 .Ic path
 to navigate to the session path:
 .Pp
 .Dl $ cd `remux p`
 .Pp
 .Sh SEE ALSO
 .Xr tmux 1
 .Sh AUTHORS
 .An -nosplit
 .An Valerie Wolfe Aq Mt sleeplessval@gmail.com
--- a/sbom.xml
+++ b/sbom.xml
@ -1,260 +0,0 @@
 {
  "SPDXID": "SPDXRef-DOCUMENT",
  "creationInfo": {
    "created": "2024-03-14T20:41:35.559Z",
    "creators": [
      "Tool: cargo-sbom-v0.8.4"
    ]
  },
  "dataLicense": "CC0-1.0",
  "documentNamespace": "https://spdx.org/spdxdocs/remux-eb288ebb-1cdd-412b-87c2-b15fc96cd8bd",
  "files": [
    {
      "SPDXID": "SPDXRef-File-remux",
      "checksums": [],
      "fileName": "remux",
      "fileTypes": [
        "BINARY"
      ]
    }
  ],
  "name": "remux",
  "packages": [
    {
      "SPDXID": "SPDXRef-Package-libredox-0.0.2",
      "description": "Redox stable ABI",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/libredox@0.0.2",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "libredox",
      "versionInfo": "0.0.2"
    },
    {
      "SPDXID": "SPDXRef-Package-libc-0.2.153",
      "description": "Raw FFI bindings to platform libraries like libc.\n",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/libc@0.2.153",
          "referenceType": "purl"
        }
      ],
      "homepage": "https://github.com/rust-lang/libc",
      "licenseConcluded": "MIT OR Apache-2.0",
      "licenseDeclared": "MIT OR Apache-2.0",
      "name": "libc",
      "versionInfo": "0.2.153"
    },
    {
      "SPDXID": "SPDXRef-Package-numtoa-0.1.0",
      "description": "Convert numbers into stack-allocated byte arrays",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/numtoa@0.1.0",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT OR Apache-2.0",
      "licenseDeclared": "MIT OR Apache-2.0",
      "name": "numtoa",
      "versionInfo": "0.1.0"
    },
    {
      "SPDXID": "SPDXRef-Package-termion-2.0.3",
      "description": "A bindless library for manipulating terminals.",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/termion@2.0.3",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "termion",
      "versionInfo": "2.0.3"
    },
    {
      "SPDXID": "SPDXRef-Package-pico-args-0.5.0",
      "description": "An ultra simple CLI arguments parser.",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/pico-args@0.5.0",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "pico-args",
      "versionInfo": "0.5.0"
    },
    {
      "SPDXID": "SPDXRef-Package-redox_termios-0.1.3",
      "description": "A Rust library to access Redox termios functions",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/redox_termios@0.1.3",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "redox_termios",
      "versionInfo": "0.1.3"
    },
    {
      "SPDXID": "SPDXRef-Package-remux-0.2.1",
      "description": "A friendly command shortener for tmux",
      "downloadLocation": "NONE",
      "homepage": "https://git.vwolfe.io/valerie/remux",
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "remux",
      "versionInfo": "0.2.1"
    },
    {
      "SPDXID": "SPDXRef-Package-bitflags-2.4.2",
      "description": "A macro to generate structures which behave like bitflags.\n",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/bitflags@2.4.2",
          "referenceType": "purl"
        }
      ],
      "homepage": "https://github.com/bitflags/bitflags",
      "licenseConcluded": "MIT OR Apache-2.0",
      "licenseDeclared": "MIT OR Apache-2.0",
      "name": "bitflags",
      "versionInfo": "2.4.2"
    },
    {
      "SPDXID": "SPDXRef-Package-bitflags-1.3.2",
      "description": "A macro to generate structures which behave like bitflags.\n",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/bitflags@1.3.2",
          "referenceType": "purl"
        }
      ],
      "homepage": "https://github.com/bitflags/bitflags",
      "licenseConcluded": "MIT OR Apache-2.0",
      "licenseDeclared": "MIT/Apache-2.0",
      "name": "bitflags",
      "versionInfo": "1.3.2"
    },
    {
      "SPDXID": "SPDXRef-Package-redox_syscall-0.4.1",
      "description": "A Rust library to access raw Redox system calls",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/redox_syscall@0.4.1",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "redox_syscall",
      "versionInfo": "0.4.1"
    },
    {
      "SPDXID": "SPDXRef-Package-tmux_interface-0.2.1",
      "description": "Rust language library for communication with TMUX via CLI",
      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
      "externalRefs": [
        {
          "referenceCategory": "PACKAGE-MANAGER",
          "referenceLocator": "pkg:cargo/tmux_interface@0.2.1",
          "referenceType": "purl"
        }
      ],
      "licenseConcluded": "MIT",
      "licenseDeclared": "MIT",
      "name": "tmux_interface",
      "versionInfo": "0.2.1"
    }
  ],
  "relationships": [
    {
      "relatedSpdxElement": "SPDXRef-Package-libc-0.2.153",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-termion-2.0.3",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-redox_syscall-0.4.1",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-numtoa-0.1.0",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-tmux_interface-0.2.1",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-pico-args-0.5.0",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-redox_termios-0.1.3",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-libc-0.2.153",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-bitflags-1.3.2",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-redox_syscall-0.4.1"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-remux-0.2.1",
      "relationshipType": "GENERATED_FROM",
      "spdxElementId": "SPDXRef-File-remux"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-bitflags-2.4.2",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
    },
    {
      "relatedSpdxElement": "SPDXRef-Package-libredox-0.0.2",
      "relationshipType": "DEPENDS_ON",
      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
    }
  ],
  "spdxVersion": "SPDX-2.3"
 }
--- a/src/command.rs
+++ b/src/command.rs
@ -0,0 +1,159 @@
 use std::{
 	env::current_dir,
 	process::exit
 };
 use pico_args::Arguments;
 use termion::{ color, style };
 use tmux_interface::TmuxCommand;
 use crate::error;
 use crate::util;
 pub fn attach(pargs: &mut Arguments) {
 	util::prevent_nest();
 	//	get optional flags
 	let read_only = pargs.contains(["-r", "--readonly"]);
 	let detach_other = pargs.contains(["-d", "--detach"]);
 	//	get target and error out if not provided
 	let args = pargs.clone().finish();
 	if args.len() < 1 { error::missing_target(); }
 	let target = args.get(0).unwrap().to_string_lossy();
 	let window = args.get(1);
 	//	focus window if provided
 	if window.is_some() {
 		let target = window.unwrap().to_string_lossy();
 		let tmux = TmuxCommand::new();
 		tmux
 			.select_window()
 			.target_window(target)
 			.output().ok();
 	}
 	//	command
 	let tmux = TmuxCommand::new();
 	let exists = tmux
 		.has_session()
 		.target_session(target.clone())
 		.output().unwrap();
 	if !exists.success() { error::no_target(target.to_string()); }
 	let mut attach = tmux.attach_session();
 	//	handle optional flags
 	if read_only { attach.read_only(); }
 	if detach_other { attach.detach_other(); }
 	attach
 		.target_session(target)
 		.output().ok();
 }
 pub fn detach(pargs: &mut Arguments) {
 	//	get target and error out if not provided
 	let args = pargs.clone().finish();
 	if args.len() < 1 { error::missing_target(); }
 	let target = args.get(0).unwrap().to_string_lossy();
 	//	command
 	let tmux = TmuxCommand::new();
 	let exists = tmux
 		.has_session()
 		.target_session(target.clone())
 		.output().unwrap();
 	if !exists.success() { error::no_target(target.to_string()); }
 	tmux
 		.detach_client()
 		.target_session(target)
 		.output().ok();
 }
 pub fn has(pargs: &mut Arguments) {
 	//	get optional flag
 	let quiet = pargs.contains(["-q", "--quiet"]);
 	//	get target and error out if not provided
 	let args = pargs.clone().finish();
 	if args.len() < 1 { error::missing_target(); }
 	let target = args.get(0).unwrap().to_string_lossy();
 	//	command
 	let tmux = TmuxCommand::new();
 	let exists = tmux
 		.has_session()
 		.target_session(target.clone())
 		.output().unwrap();
 	let success = exists.success();
 	//	handle optional flag
 	//	inverted; print text if NOT quiet
 	if !quiet { println!("session \"{target}\" {}.", if success { "exists" } else { "does not exist" }); }
 	//	exit codes for scripts to use
 	exit( if success { 0 } else { 1 });
 }
 pub fn list() {
 	//	get session list
 	let sessions = util::get_sessions().unwrap_or(Vec::new());
 	//	handle empty case
 	if sessions.len() == 0 {
 		println!("no sessions");
 		return;
 	}
 	//	iterate over pretty print
 	println!("sessions:");
 	for session in sessions.into_iter() {
 		let group = session.group.unwrap_or("[untitled]".to_string());
 		let id = session.id.unwrap();
 		let attached = session.attached.unwrap_or(0) > 0;
 		println!(
 			"  {group} ({bold}{blue}{id}{reset}) {bold}{green}{attach_sym}{reset}",
 			//	values
 			attach_sym = if attached { "󰌹" } else {""},
 			//	formatting
 			bold = style::Bold,
 			blue = color::Fg(color::Blue),
 			green = color::Fg(color::LightGreen),
 			reset = style::Reset
 		);
 	}
 }
 pub fn new(pargs: &mut Arguments) {
 	use pico_args::Error;
 	//	show nest message
 	util::prevent_nest();
 	//	get optional flag
 	let target_dir: Result<String, Error> = pargs.value_from_str(["-t", "--target"]);
 	//	get target and error out if not provided
 	let args = pargs.clone().finish();
 	if args.len() < 1 { error::missing_target(); }
 	//	get target session and optional command
 	let title = args.get(0).unwrap().to_string_lossy();
 	let command = args.get(1);
 	let tmux = TmuxCommand::new();
 	let mut new = tmux.new_session();
 	if command.is_some() { new.shell_command(command.unwrap().to_string_lossy()); }
 	new
 		.group_name(title)
 		.attach()
 		.start_directory(target_dir.unwrap_or(current_dir().unwrap().to_string_lossy().to_string()))
 		.output().ok();
 }
--- a/src/command/mod.rs
+++ b/src/command/mod.rs
@ -1,4 +0,0 @@
 pub mod share;
 pub mod session;
--- a/src/command/session.rs
+++ b/src/command/session.rs
@ -1,67 +0,0 @@
 //!	commands accessible from within a session
 use tmux_interface::{
 	Tmux,
 	commands
 };
 use crate::{
 	error,
 	state::State,
 	util::{
 		self,
 		message,
 		MSG_PREVIOUS, MSG_SESSION_PATH, NULL
 	}
 };
 pub fn path(state: &mut State) {
 	state.session_enforce("path");
 	if let Some(message) = message(MSG_SESSION_PATH) {
 		println!("{message}");
 	}
 }
 pub fn switch(state: &mut State) {
 	util::terminal_enforce();
 	//	refuse to run outside a session
 	state.session_enforce("switch");
 	//	consume optional flags
 	let read_only = state.flags.read_only;
 	let detach_other = state.flags.detached;
 	let args = state.args.clone().finish();
 	let target: String = match if let Some(inner) = args.get(0) { inner.to_str() } else { None } {
 		None		|
 		Some("-")	=>	if let Some(prev) = message(MSG_PREVIOUS) { prev }
 						else { error::missing_target() },
 		Some(inner)	=>	inner.to_owned()
 	};
 	let exists = util::session_exists(target.clone());
 	if !exists { error::no_target(target.clone()); }
 	let mut tmux = Tmux::new();
 	if detach_other {
 		let detach = commands::DetachClient::new()
 			.target_session(&target);
 		tmux = tmux.add_command(detach);
 	}
 	let mut switch = commands::SwitchClient::new();
 	switch = switch.target_session(&target);
 	if read_only { switch.read_only = true; }
 	tmux.add_command(switch)
 		.stderr(NULL).output().ok();
 }
 pub fn title(state: State) {
 	state.session_enforce("title");
 	if let Some(title) = state.title { println!("{title}"); }
 }
--- a/src/command/share.rs
+++ b/src/command/share.rs
@ -1,216 +0,0 @@
 //! globally available tmux commands.
 use std::process::exit;
 use pico_args::{ Arguments, Error };
 use termion::{ color, style };
 use tmux_interface::{
 	Tmux,
 	commands
 };
 use crate::{
 	env::{
 		self,
 		env_var,
 		SYMBOL_ATTACH, SYMBOL_CURRENT, SYMBOL_PREV
 	},
 	error,
 	flag,
 	state::State,
 	util::{
 		self,
 		message,
 		MSG_PREVIOUS, NULL
 	}
 };
 pub fn attach(state: &mut State) {
 	util::terminal_enforce();
 	state.nest_init();
 	//	consume optional flags
 	let read_only = state.flags.read_only;
 	let detach_other = state.flags.detached;
 	//	consume arguments
 	let target = state.target_title().unwrap();
 	let window = state.target();
 	//	do not allow attaching to the same session
 	if state.session && target == state.title.clone().unwrap() { error::same_session(); }
 	//	make sure the session exists
 	let exists = util::session_exists(target.clone());
 	if !exists { error::no_target(target.clone()); }
 	//	 build attach command
 	let mut attach = commands::AttachSession::new();
 	attach = attach.target_session(target);
 	if read_only { attach.read_only = true; }
 	if detach_other { attach.detach_other = true; }
 	let select_window: Option<commands::SelectWindow>;
 	if let Some(window) = window {
 		let mut command = commands::SelectWindow::new();
 		command.target_window = Some(window.into());
 		select_window = Some(command);
 	} else { select_window = None; }
 	//	build dispatch
 	let mut tmux = Tmux::new().add_command(attach);
 	if let Some(select_window) = select_window { tmux = tmux.add_command(select_window); }
 	tmux.stderr(NULL).output().ok();
 	state.nest_deinit();
 }
 pub fn context_action(state: &mut State) {
 	if !state.session {
 		if let Some(repository) = &state.repository {
 			let target = repository.name.clone();
 			let mut args = Arguments::from_vec( vec![(&target).into()] );
 			let mut substate = State::new(&mut args);
 			substate.flags = state.flags.clone();
 			if util::session_exists(&target) {
 				attach(&mut substate);
 			} else {
 				new(&mut substate);
 			}
 			return;
 		}
 	}
 	//	fallback behavior is list
 	list(state);
 }
 pub fn detach(state: &mut State) {
 	util::terminal_enforce();
 	let target = state.target_title().unwrap();
 	//	make sure the session exists
 	let exists = util::session_exists(target.clone());
 	if !exists { error::no_target(target.clone()); }
 	//	build and dispatch
 	let detach = commands::DetachClient::new()
 		.target_session(target);
 	Tmux::new()
 		.add_command(detach)
 		.disable_echo().output().ok();
 }
 pub fn has(state: &mut State) {
 	//	consume optional flags
 	let quiet = state.flags.quiet;
 	//	get target
 	let target = state.target_title().unwrap();
 	//	run command
 	let success = util::session_exists(target.clone());
 	//	print if not quiet
 	if !quiet {
 		println!("session \"{target}\" {}.",
 			if success { "exists" }
 			else { "does not exist" }
 		);
 	}
 	//	emit exit code
 	exit( if success { 0 } else { 1 });
 }
 pub fn list(state: &mut State) {
 	//	get session list
 	let sessions = util::get_sessions().unwrap_or(Vec::new());
 	let search = state.target();
 	let previous = message(MSG_PREVIOUS);
 	//	handle empty case
 	if sessions.len() == 0 {
 		if !state.flags.quiet { println!("no sessions"); }
 		return;
 	}
 	//	get attached session symbol
 	let attach_symbol	= env_var(SYMBOL_ATTACH);
 	let current_symbol	= env_var(SYMBOL_CURRENT);
 	let prev_symbol		= env_var(SYMBOL_PREV);
 	//	pretty print session list
 	if !state.flags.quiet { println!("sessions:"); }
 	for session in sessions {
 		let name = session.name.unwrap_or("[untitled]".to_string());
 		if search.is_some() && !name.starts_with(search.as_ref().unwrap()) { continue; }
 		if !state.flags.quiet {
 			let id = session.id.unwrap();
 			let attached = session.attached.unwrap_or(0) > 0;
 			let compare = Some(name.clone());
 			let marker =
 				if compare == state.title { current_symbol.clone() }
 				else if state.session && compare == previous { prev_symbol.clone() }
 				else { " ".to_string() };
 			println!(
 				" {marker} {name}{reset} ({bold}{blue}{id}{reset}) {bold}{green}{attach}{reset}",
 				//	values
 				attach		= if attached { attach_symbol.clone() } else { "".to_string() },
 				//	formatting
 				bold		= style::Bold,
 				blue		= color::Fg(color::Blue),
 				green		= color::Fg(color::LightGreen),
 				reset		= style::Reset,
 			);
 		} else {
 			print!("{name} ");
 		}
 	}
 }
 pub fn new(state: &mut State) {
 	util::terminal_enforce();
 	//	get optional flags
 	let detached = state.flags.detached;
 	let target_dir: Result<String, Error> = state.args.value_from_str(flag::TARGET);
 	//	delayed nest_init; detached behavior conflicts with nest
 	if !detached { state.nest_init(); }
 	else if state.flags.nested { error::conflict_nest(Some("detached session is not nesting")); }
 	//	get environment variables
 	let window_name = env_var(env::NEW_WINDOW_NAME);
 	//	consume arguments
 	let title = state.target_title().unwrap();
 	let command = state.target();
 	//	don't allow duplicate names
 	let exists = util::session_exists(title.clone());
 	if exists { error::target_exists(title.clone()); }
 	let mut new = commands::NewSession::new();
 	new = new.session_name(title);
 	if let Some(command) = command { new.shell_command = Some(command.into()); }
 	if detached { new.detached = true; }
 	if let Ok(target_dir) = target_dir { new = new.start_directory(target_dir); }
 	let mut tmux = Tmux::new().add_command(new);
 	//	rename window if var not empty
 	if !window_name.is_empty() {
 		let auto_name = commands::RenameWindow::new()
 			.new_name(window_name);
 		tmux = tmux.add_command(auto_name);
 	}
 	tmux.stderr(NULL).output().ok();
 }
--- a/src/env.rs
+++ b/src/env.rs
@ -1,17 +0,0 @@
 use std::env::var;
 pub type EnvVar = (&'static str, &'static str);
 pub const NEW_WINDOW_NAME:	EnvVar	= ("REMUX_NEW_WINDOW", "");
 pub const REPO_FILE:		EnvVar	= ("REMUX_REPO_FILE", ".git");
 pub const SYMBOL_ATTACH:	EnvVar	= ("REMUX_ATTACH_SYMBOL", "*");
 pub const SYMBOL_CURRENT:	EnvVar	= ("REMUX_CURRENT_SYMBOL", ">");
 pub const SYMBOL_PREV:		EnvVar	= ("REMUX_PREVIOUS_SYMBOL", "-");
 pub const TMUX: &str				= "TMUX";
 ///	get or default an environment variable
 pub fn env_var(envvar: EnvVar) -> String {
 	var(envvar.0).unwrap_or(envvar.1.to_string())
 }
--- a/src/error.rs
+++ b/src/error.rs
@ -1,84 +1,44 @@
 use std::process::exit;
 ///	no subcommand that matches user input; code 1
-pub fn no_subcommand(subcommand: String) -> ! {
+pub fn no_subcommand(subcommand: String) {
-	eprintln!("remux: no command match for \"{subcommand}\"");
+	println!("remux: no command match for \"{subcommand}\"");
 	exit(1);
 }
 ///	target session not found; code 2
-pub fn no_target<S: Into<String>>(target: S) -> ! {
+pub fn no_target(target: String) {
-	let target = target.into();
+	println!("remux: no session \"{target}\" exists");
-	eprintln!("remux: no session \"{target}\" exists");
+	exit(2);
 }
 ///	no sessions exist; code 2
 pub fn no_sessions() {
 	println!("remux: no sessions running");
 	println!("use 'remux n <title>' to create a new session");
 	exit(2);
 }
 ///	help topic doesn't exist; code 3
-pub fn no_help(topic: String) -> ! {
+pub fn no_help(topic: String) {
-	eprintln!("remux: no help for \"{topic}\"");
+	println!("remux: no help for \"{topic}\"");
 	exit(3);
 }
 ///	user provided no target; code 4
-pub fn missing_target() -> ! {
+pub fn missing_target() {
-	eprintln!("remux: no target provided");
+	println!("remux: no target provided");
 	exit(4);
 }
 ///	refuse to attach to current session; code 4
 pub fn same_session() -> ! {
 	eprintln!("remux: cannot attach to same session");
 	exit(4);
 }
 ///	a session with the target name already exists; code 4
 pub fn target_exists<S: Into<String>>(target: S) -> ! {
 	let target = target.into();
 	eprintln!("remux: session \"{target}\" already exists");
 	exit(4);
 }
 ///	non-terminal environment prevention; code 5
-pub fn not_terminal() -> ! {
+pub fn not_terminal() {
-	eprintln!("remux: not running from a terminal");
+	println!("remux: not running from a terminal");
 	exit(5);
 }
 ///	tried to nest while not in a session; code 6
-pub fn not_nesting() -> ! {
+pub fn not_nesting() {
-	eprintln!("remux: inappropriate nesting flag (-n); not in a session");
+	println!("remux: cannot use nesting flag outside a TMUX session");
 	exit(6);
 }
 ///	operation requires nesting flag; code 6
 pub fn prevent_nest() -> ! {
 	eprintln!("remux: the nesting flag (-n) is required for nesting operation");
 	exit(6);
 }
 ///	operation conflicts with nesting flag; code 6
 pub fn conflict_nest(reason: Option<&'static str>) -> ! {
 	if let Some(reason) = reason { eprintln!("remux: inappropriate nesting flag (-n): {reason}"); }
 	else { eprintln!("remux: nesting flag (-n) is inappropriate for this operation."); }
 	exit(6);
 }
 ///	tried to run a session command outside a session; code 7
 pub fn not_in_session(cmd: &'static str) -> ! {
 	eprintln!("remux: '{cmd}' must be run from within a session");
 	exit(7);
 }
 ///	failed to set working directory; code 8
 pub fn working_dir_fail(working_dir: &str) -> ! {
 	eprintln!("remux: failed to set working directory to '{working_dir}'");
 	exit(8);
 }
--- a/src/flag.rs
+++ b/src/flag.rs
@ -1,56 +0,0 @@
 use pico_args::Arguments;
 type Flag = [&'static str;2];
 pub static DETACH: Flag			= [ "-d", "--detach" ];
 pub static HELP: Flag			= [ "-h", "--help" ];
 pub static NEST: Flag			= [ "-n", "--nest" ];
 pub static QUIET: Flag			= [ "-q", "--quiet" ];
 pub static READ_ONLY: Flag		= [ "-r", "--read-only" ];
 pub static TARGET: Flag			= [ "-t", "--target" ];
 pub static VERSION: Flag		= [ "-v", "--version" ];
 pub static WORKING_DIR: Flag	= [ "-D", "--dir" ];
 pub struct Flags {
 	pub detached: bool,
 	pub nested: bool,
 	pub quiet: bool,
 	pub read_only: bool,
 	pub target: Option<String>,
 	pub working_dir: Option<String>
 }
 impl Flags {
 	pub fn from(args: &mut Arguments) -> Flags {
 		let detached	= args.contains(DETACH);
 		let nested		= args.contains(NEST);
 		let quiet		= args.contains(QUIET);
 		let read_only	= args.contains(READ_ONLY);
 		let target		= args.value_from_str(TARGET).ok();
 		let working_dir	= args.value_from_str(WORKING_DIR).ok();
 		Flags {
 			detached,
 			nested,
 			quiet,
 			read_only,
 			target,
 			working_dir
 		}
 	}
 	pub fn clone(&self) -> Flags {
 		Flags {
 			detached: self.detached,
 			nested: self.nested,
 			quiet: self.quiet,
 			read_only: self.read_only,
 			target: self.target.clone(),
 			working_dir: self.working_dir.clone()
 		}
 	}
 }
--- a/src/help.rs
+++ b/src/help.rs
@ -1,169 +1,98 @@
 use std::process::exit;
 use pico_args::Arguments;
 use crate::error;
 use crate::VERSION;
 pub fn help(pargs: &mut Arguments) {
 	let topic = pargs.subcommand().unwrap();
 	match topic.as_deref() {
-		None =>
+		None => {
-println!("remux v{VERSION}
+			println!("remux v{}", env!("CARGO_PKG_VERSION"));
-Valerie Wolfe <sleeplessval@gmail.com>
+			println!("Valerie Wolfe <sleeplessval@gmail.com>");
-A command wrapper for tmux written in Rust.
+			println!("A command wrapper for tmux written in Rust.\n");
-usage: remux [command] [<args>]
+			println!("usage: remux <command> [<args>]\n");
-commands:
+			println!("Commands:");
-   help       Show help text for remux, a command, or a help topic.
+			println!("   help       Show help text for remux or a specific command");
-   attach     Attach to an existing tmux session
+			println!("   attach     Attach to an existing tmux session");
-   detach     Detach clients from a tmux session
+			println!("   detach     Detach clients from a tmux session");
-   has        Check if a tmux session exists
+			println!("   has        Check if a tmux session exists");
-   list       Pretty-print all tmux sessions
+			println!("   list       Pretty-print all tmux sessions");
-   new        Create a new tmux session
+			println!("   new        Create a new tmux session");
-   path       print session path (session)
+			println!("\nUse 'remux help <command>' to see detailed help text for each command.");
-   switch     switch to another session (session)
+		},
   title      print session title (session)
 Use 'remux help <command>' to see detailed help text for each command.
 help topics:
   env        Environment variables"),
 //	COMMAND HELP
 		Some("a" | "attach")
-		=>
+		=> {
-println!("remux attach
+			println!("remux attach");
-Attach to an existing session.
+			println!("Attach to an existing session.\n");
-usage: remux attach [flags] <session> [window]
+			println!("usage: remux attach [flags] <session> [window]\n");
       remux a [flags] <session> [window]
-args:
+			println!("args:");
-   <session>          The session to attach to
+			println!("   <session>          The session to attach to");
-   [window]           Optionally focus a window in the given session
+			println!("   [window]           Optionally focus a window in the given session\n");
-flags:
+			println!("flags:");
-   -d, --detach       Detach other attached clients from the session
+			println!("   -d, --detach       Detach other attached clients from the session");
-   -n, --nest         Attach the session inside another session.
+			println!("   -r, --readonly     Attach the session as read-only");
-   -r, --read-only    Attach the session as read-only"),
+		},
 		Some("d" | "detach")
-		=>
+		=> {
-println!("remux detach
+			println!("remux detach");
-Detach all clients from a session.
+			println!("Detach all clients from a session.\n");
-usage: remux detach <session>
+			println!("usage: remux detach <session>\n");
       remux d <session>
-args:
+			println!("args:");
-   <session>      The session name to detach clients from"),
+			println!("   <session>      The session name to detach clients from");
 		},
-		Some("h" | "has")
+		Some("has")
-		=>
+		=> {
-println!("remux has
+			println!("remux has");
-Check if the target session exists.
+			println!("Check if the target session exists.\n");
-usage: remux has [flags] <session>
+			println!("usage: remux has [flags] <session>\n");
       rmux h [flags] session
-args:
+			println!("args:");
-   <session>      The session to check for
+			println!("   <session>      The session to check for\n");
-flags:
+			println!("flags:");
-   -q, --quiet    Display no text; exit code only"),
+			println!("   -q, --quiet    Display no text; exit code only");
 		},
 		Some("l" | "ls" | "list")
-		=>
+		=> {
-println!("remux list
+			println!("remux list");
-Pretty-print all tmux sessions.
+			println!("Pretty-print all tmux sessions.\n");
-usage: remux list
+			println!("usage: remux list");
-       remux ls
+		},
       remux l"),
 		Some("n" | "new")
-		=>
+		=> {
-println!("remux new
+			println!("remux new");
-Create a new tmux session.
+			println!("Create a new tmux session.\n");
-usage: remux new [flags] <title> [command]
+			println!("usage: remux new [flags] <title> [command]\n");
       remux n [flags] <title> [command]
-args:
+			println!("args:");
-   <title>                The title of the new session
+			println!("   <title>                The title of the new session");
-   [command]              The shell command to run
+			println!("   [command]              The shell command to run\n");
-flags:
+			println!("flags:");
-   -n, --nest             Create the session inside another session.
+			println!("   -t, --target <dir>     Sets the target directory for the new session.");
-   -t, --target <dir>     Sets the target directory for the new session."),
+		},
 		Some("p" | "path")
 		=>
 println!("remux path
 Print the session path (#{{session_path}}) to standard output.
 Must be run from inside a session.
 usage: remux path
       remux p"),
 		Some("s" | "switch")
 		=>
 println!("remux switch
 Switch to a different tmux session.
 Must be run from inside a session.
 usage: remux switch [flags] <title>
       remux s [flags] <title>
 args:
   <title>                The title of the session to switch to.
 flags:
   -r, --read-only        Attach the target session as read-only."),
 		Some("w" | "which" | "title")
 			=>
 println!("remux which
 Print the title of the current session.
 usage: remux which
       remux w
       remux title"),
 //	TOPIC HELP
 		Some("env" | "vars")
 			=>
 println!("remux environment variables
 REMUX_ATTACH_SYMBOL
   Changes the symbol displayed for attached sessions displayed
   by the 'list' command.
   Default: '*'
 REMUX_CURRENT_SYMBOL
   Changes the symbol displayed to denote the current session
   in the 'list' command.
   Default: '>'
 REMUX_NEW_WINDOW
   Provides a default window name when creating a session with
   the 'new' command, if not empty.
   Default: (unset)"),
 								//	not found
 		_	=>	error::no_help(topic.unwrap())
 	}
 }
 pub fn version() {
 	println!("remux v{VERSION}");
 }
--- a/src/main.rs
+++ b/src/main.rs
@ -1,72 +1,66 @@
 use std::{
 	env::{ set_var, var },
 	io::{ stdout, IsTerminal }
 };
 use pico_args::Arguments;
 mod command;
 mod env;
 mod error;
 mod flag;
 mod help;
 mod state;
 mod util;
-use help::{ help, version };
+use help::help;
 use state::State;
 static VERSION: &str = env!("CARGO_PKG_VERSION");
 fn main() {
 	//	collect args
 	let mut args = Arguments::from_env();
 	//	consume flags
-	if args.contains(flag::HELP) {
+	if args.contains(["-h", "--help"]) {
 		help(&mut args);
 		return;
 	}
-
+	let nesting = args.contains(["-n", "--nest"]);
-	if args.contains(flag::VERSION) {
+	let tmux_var = var("TMUX").ok();
-		version();
+	if nesting {
-		return;
+		if tmux_var.is_none() {
 			error::not_nesting();
 		}
 		set_var("TMUX", "");
 	}
-	let mut state = State::new(&mut args);
+	if !stdout().is_terminal() { error::not_terminal(); }
-	let target = state.target();
+	let subcommand = args.subcommand().unwrap();
 	//	invoke subcommand function
-	match target.as_deref() {
+	match subcommand.as_deref() {
-		Some("help")
+		Some("h" | "help")
 			=>	help(&mut args),
 		None
 			=>	command::share::context_action(&mut state),
 		Some("a" | "attach")
-			=>	command::share::attach(&mut state),
+			=>	command::attach(&mut args),
 		Some("d" | "detach")
-			=>	command::share::detach(&mut state),
+			=>	command::detach(&mut args),
-		Some("h" | "has")
+		Some("has")
-			=>	command::share::has(&mut state),
+			=>	command::has(&mut args),
 		None |
 		Some("l" | "ls" | "list")
-			=>	command::share::list(&mut state),
+			=>	command::list(),
 		Some("n" | "new")
-			=>	command::share::new(&mut state),
+			=>	command::new(&mut args),
 		Some("p" | "path")
 			=>	command::session::path(&mut state),
 		Some("s" | "switch")
 			=>	command::session::switch(&mut state),
 		Some("t" | "title" | "which")
 			=>	command::session::title(state),
 		_
-			=>	error::no_subcommand(target.unwrap())
+			=>	error::no_subcommand(subcommand.unwrap())
 	}
 	if nesting {
 		set_var("TMUX", tmux_var.unwrap());
 	}
 }
--- a/src/state.rs
+++ b/src/state.rs
@ -1,103 +0,0 @@
 use std::{
 	env,
 	path::PathBuf
 };
 use pico_args::Arguments;
 use crate::{
 	env::{ env_var, REPO_FILE, TMUX },
 	error,
 	flag::Flags,
 	util::{ find, message, MSG_SESSION_NAME }
 };
 pub struct State<'a> {
 	pub args: &'a mut Arguments,
 	pub flags: Flags,
 	pub session: bool,
 	tmux_var: Option<String>,
 	pub title: Option<String>,
 	pub repository: Option<Repository>
 }
 impl State<'_> {
 	pub fn new(args: &mut Arguments) -> State {
 		let flags = Flags::from(args);
 		let tmux_var = env::var(TMUX).ok();
 		let session = tmux_var.is_some();
 		if let Some(ref path) = flags.working_dir { State::set_working_dir(&path); }
 		let title = if session { message(MSG_SESSION_NAME) } else { None };
 		let repository = Repository::find();
 		State {
 			args,
 			flags,
 			session,
 			tmux_var,
 			title,
 			repository
 		}
 	}
 	pub fn nest_init(&self) {
 		if self.flags.nested {
 			if self.session { env::set_var(TMUX, ""); }		//	nesting & session	=> ok
 			else { error::not_nesting(); }					//	nesting & !session	=> error
 		} else if self.session { error::prevent_nest(); }	//	!nesting & session	=> error
 															//	!nesting & !session	=> ok
 	}
 	pub fn nest_deinit(&self) {
 		if self.flags.nested && self.session {
 			env::set_var(TMUX, self.tmux_var.as_ref().unwrap());
 		}
 	}
 	pub fn session_enforce(&self, cmd: &'static str) {
 		if !self.session { error::not_in_session(cmd); }
 	}
 	fn set_working_dir(path: &str) {
 		let result = env::set_current_dir(path);
 		if result.is_err() {
 			error::working_dir_fail(path);
 		}
 	}
 	pub fn target(&mut self) -> Option<String> { self.args.subcommand().unwrap_or(None) }
 	pub fn target_title(&mut self) -> Option<String> {
 		let from_args = self.target();
 		if from_args.is_some() { return from_args; }
 		else if let Some(repository) = &self.repository { Some(repository.name.clone()) }
 		else { error::missing_target() }
 	}
 }
 pub struct Repository {
 	pub path: PathBuf,
 	pub name: String
 }
 impl Repository {
 	pub fn find() -> Option<Repository> {
 		let path = find(&env_var(REPO_FILE), env::current_dir().unwrap());
 		if let Some(path) = path {
 			let name = path.file_name().unwrap().to_string_lossy().to_string();
 			let inner = Repository {
 				path,
 				name
 			};
 			Some(inner)
 		} else { None }
 	}
 }
--- a/src/util.rs
+++ b/src/util.rs
@ -1,67 +1,29 @@
 use std::{
-	io::{ stdout, IsTerminal },
+	env::var,
-	path::PathBuf
+	process::exit
 };
 use tmux_interface::{
-	Session, StdIO, Tmux,
+	Session, Sessions,
-
+	variables::session::session::SESSION_ALL
 	commands,
 	variables::session::SessionsCtl
 };
 use crate::error;
 pub const NULL: Option<StdIO> = Some(StdIO::Null);
 pub const MSG_PREVIOUS:		&str	= "#{client_last_session}";
 pub const MSG_SESSION_NAME:	&str	= "#S";
 pub const MSG_SESSION_PATH:	&str	= "#{session_path}";
 pub const MSG_WINDOW_NAME:	&str	= "#{window_name}";
 pub fn message(fstr: &str) -> Option<String> {
 	let message = commands::DisplayMessage::new().print().message(fstr);
 	let result = Tmux::new().add_command(message).output();
 	if let Ok(output) = result {
 		let text = String::from_utf8(output.0.stdout);
 		if let Ok(title) = text {
 			if title.len() > 0 { Some(title[0..title.len() - 1].to_owned()) }
 			else { None }
 		} else { None }
 	} else { None }
 }
 ///	return a Vec of all sessions or None
 pub fn get_sessions() -> Option<Vec<Session>> {
-	let sessions = SessionsCtl::new().get_all();
+	let i_sessions = Sessions::get(SESSION_ALL);
-	if let Ok(sessions) = sessions {
+	if i_sessions.is_err() { return None; }
-		return Some(sessions.0);
+	let sessions = i_sessions.ok();
-	} else { return None; }
+	if sessions.is_none() { return None; }
 	Some(sessions.unwrap().0)
 }
-///	check whether a target session exists
+///	show the tmux nest text if env var is not unset
-pub fn session_exists<S: Into<String>>(target: S) -> bool {
+pub fn prevent_nest() {
-	let has_session = commands::HasSession::new()
+	let tmux = var("TMUX").ok();
-		.target_session(target.into());
+	if tmux.is_some() && tmux.unwrap() != "" {
-	Tmux::new().add_command(has_session)
+		println!("Sessions should be nested with care; unset TMUX or use the '-n' flag to allow.");
-		.stderr(NULL)
+		exit(1);
-		.status()
+	}
 		.unwrap()
 		.success()
 }
 ///	enforce a command is being run in a terminal
 pub fn terminal_enforce() {
 	if !stdout().is_terminal() { error::not_terminal(); }
 }
 ///	recursively propagate up directories to find a child
 pub fn find(target: &str, path: PathBuf) -> Option<PathBuf> {
 	if path.join(target).exists() { return Some(path); }
 	let parent = path.parent();
 	if let Some(parent) = parent { return find(target, parent.to_path_buf()) }
 	else { None }
 }