Eternal Terminal

New in 2.1.0

The ET protocol arrives with ZestSSH 2.1.0. Earlier versions offer Mosh for roaming sessions.

Eternal Terminal (ET) is a remote shell that automatically reconnects without losing the session: close the laptop, change networks, lose Wi-Fi for a minute, and the same shell with the same scrollback is waiting when the link comes back. ZestSSH supports it on desktop the way it supports Mosh: by running the system et client and piping its I/O into the built-in terminal.

Availability

Platform	Status
Android	Not available
iOS	Not available
Windows	Supported (via WSL)
macOS	Full support
Linux	Full support

Eternal Terminal is a desktop-only protocol. On mobile, ZestSSH shows a message suggesting SSH with keep-alive and auto-reconnect instead.

What Is Eternal Terminal?

• Persistent sessions: the session lives on the server in etserver; the client reconnects to it after any interruption, including your machine sleeping.
• Scrollback survives: unlike Mosh, ET keeps native scrollback, so what scrolled past while you were disconnected is still there.
• TCP-based: ET uses an ordinary TCP connection (port 2022 by default), so it works through firewalls that block Mosh’s UDP.
• SSH for the handshake: et first connects over SSH to exchange a per-session key, then switches to its own encrypted protocol.

Server Requirements

etserver must be installed and running on the remote host, listening on its port (2022 by default).

# Ubuntu/Debian
sudo apt install et

# Fedora
sudo dnf install et

# Arch Linux
sudo pacman -S eternalterminal

# macOS (Homebrew)
brew install MisterTea/et/et

The server’s firewall must allow inbound TCP on the etserver port, and SSH must still be reachable on the port you configure for the connection.

Client Requirements

macOS / Linux

Install et with your package manager (same packages as above). ZestSSH calls the et binary from PATH.

Windows

ET on Windows runs through WSL (Windows Subsystem for Linux):

1. Install WSL: wsl --install
2. Inside WSL, install et: wsl sudo apt install et
3. ZestSSH automatically runs wsl et ... when connecting.

ZestSSH checks for both WSL availability and et inside WSL before attempting a connection.

Quick Start

1. Create a new connection and choose ET as the protocol (or pick New Eternal Terminal from the host grid’s right-click menu on desktop).
2. Enter the hostname, the SSH port (used for the handshake, default 22) and an identity.
3. Connect. ZestSSH checks that et is installed, then launches the session.

How It Works

1. Availability check: which et on Unix, wsl which et on Windows.
2. Argument construction: et --port 2022 [--ssh-option Port=<ssh port>] [--ssh-option IdentityFile=<key> --ssh-option IdentitiesOnly=yes] user@host. Host and user names are validated against a strict character set and may not begin with a dash, so nothing you type can be mistaken for an option by either binary. et executes ssh with an argument vector, not through a shell.
3. Key handling: a stored SSH key is written to a temporary file readable only by you, handed to et for the handshake, and deleted when the session ends (the same mechanism Mosh uses).
4. Process launch: et runs as a subprocess with TERM=xterm-256color; its stdout and stderr are shown in the terminal and your keystrokes go to its stdin.
5. Cleanup: on disconnect ZestSSH sends Ctrl+D so the remote shell exits cleanly, waits briefly, then terminates the process if it is still running.

Configuration

Parameter	Default	Description
Host	(required)	Remote server hostname or IP
Port	22	SSH port for the handshake
Identity	(optional)	SSH identity for authentication
etserver port	2022	The port etserver listens on. ZestSSH uses the default; change it in /etc/et.cfg on the server if you must, and keep it at 2022 for ZestSSH

Limitations

• Desktop only: not available on Android or iOS.
• Requires system et: ZestSSH does not bundle the et binary.
• Requires etserver: the remote host must run etserver with its TCP port open.
• etserver port is fixed at 2022 in this release.
• Key or agent authentication: the handshake runs inside et’s own ssh, which has no terminal to prompt on, so a password-only identity cannot authenticate. Use a key.
• No port forwarding, SFTP or agent forwarding through the ET session; open a separate SSH connection for those.
• Terminal resize is best-effort: the process runs on pipes rather than a PTY, so the remote shell picks up a new size when it next redraws.
• Windows requires WSL.

Troubleshooting

”Eternal Terminal is not installed or not available”

• Verify et is installed: which et (or wsl which et on Windows).
• On Windows, check WSL works: wsl --status.

”Permission denied” or the session ends right after connecting

• The identity must be a key (see Limitations). Check that the key is authorised on the server.
• etterminal must be on the server’s PATH for the user you log in as; on some macOS servers it lives in /usr/local/bin.

The session connects over SSH but never switches to ET

• Check that etserver is running: systemctl status et on the server.
• Make sure TCP port 2022 is open between you and the server.

FAQ

Q: Mosh or Eternal Terminal? A: Mosh is best on very lossy links and gives instant local echo; ET keeps your scrollback, works over TCP through strict firewalls, and reconnects after your machine sleeps. Many people run ET and start tmux inside it.

Q: Is the traffic encrypted? A: Yes. After the SSH handshake, et and etserver encrypt the session with a per-session key (libsodium secretbox). The SSH stack’s guarantees described elsewhere in these docs apply only to the handshake, which et’s own ssh performs.

Q: Does the session survive closing ZestSSH? A: Closing the tab sends the remote shell an end-of-input so it exits cleanly. If ZestSSH is killed outright, the server keeps the session until etserver’s own timeout; you can reconnect to it by opening the connection again.