Self-hosted · single binary · your metal

Every server.
One desktop.

helvi.sh is a self-hosted web SSH client and desktop for your server fleet. Open a browser and you get windows: shared terminals, host-to-host SFTP, monitors, containers and systemd. Folder grants decide who can open what. It ships as one Go binary with an embedded UI and a single SQLite file. The hosts only need SSH. No SaaS in the middle.

curl -fsSL https://get.helvi.sh | sudo bash
  • Single Go binary
  • SQLite, no external database
  • ~30 MB container image
  • Local accounts + OIDC SSO
The helvi.sh desktop: a live SSH terminal with linked file panel, and a system monitor window
Open an endpoint, work in a live terminal, drag a backup between hosts: a helvi.sh desktop in motion.

A real desktop, not tabs

Windows you drag, resize, minimize and restore, with a taskbar, nested folders, a trash can and wallpapers. Ctrl+K searches every endpoint, app and playbook. Your layout is saved per user and restored on sign-in.

Nothing to install on servers

helvi.sh talks plain SSH and SFTP to your endpoints. If you can ssh to it, you can manage it: no agents required, no firewall gymnastics. Want metric history? A one-file daemon is there when you opt in.

Vault, recordings, audit

SSH keys stay in the encrypted vault. Shell recording is on unless you turn it off. The audit log gets logins, sessions, transfers and admin actions. Admins are not bound by folder grants. Members are.

What's on
the desktop

Every tool opens as a window on the same desktop, against the same endpoints, under the same permissions.

Live terminals

Full xterm sessions over WebSocket with scrollback replay. Reconnect from anywhere. The PTY keeps running on the server.

Dual-pane file manager

Browse two endpoints side by side and drag files across. Host-to-host transfers stream server-side through a queued SFTP pipeline. A search box digs through remote trees by name.

System monitor

Live CPU, memory, network and storage sparklines per host, streamed over the same SSH connection. No exporters to deploy.

Containers & services

Docker containers and systemd units, in their own windows: status, logs, restart.

Run everywhere

One-shot commands and saved playbooks fanned out across many hosts at once, with per-host output collected as it lands.

SSH port forwards

SSH tunnels from a window: open a listener on the helvi host through any endpoint, and close it there.

SSH session recording

Shells record as gzipped asciicast v2 on disk. SQLite keeps the index, not the cast. Replay in the built-in player. It stores terminal output, not keystrokes.

Encrypted key vault

SSH keys and agent credentials are sealed with age (X25519) under a key that never leaves your box. Write-only from the API.

Groups & grants

Members only get the folders you grant, and only connect, read files, or write files on that grant.

2FA & lock screen

TOTP apps, email or SMS codes, backup codes, all optional or enforced org-wide. Plus a PIN lock screen with auto-lock on idle.

Audit log

Sign-ins, connections, transfers, admin changes, every agent command: timestamped, attributed, queryable from the Audit window.

Pinned web apps

Pin Grafana, your NAS, an internal wiki, or any other http(s) panel as sandboxed desktop windows next to your terminals.

Metric widgets

Pin CPU, memory, disk and network cards straight onto the wallpaper. History comes from a tiny opt-in daemon on each host, stored in your database with retention you set.

Folders & trash

Nest endpoints and playbooks in folders; permissions follow the tree down. Deletes go to a trash with a retention window, so a fat-fingered right-click isn't a disaster.

Share endpoints as files

Export any endpoint or folder as a .helvi file. Credentials stay in the vault, never in the file. Optionally passphrase-encrypt it, then a teammate drags it onto their desktop to import.

Proxmox, no shared root

Open a node's Proxmox web GUI in one click. helvi mints a short-lived, least-privilege account per person. The root password is never shared and every action has a name on it.

Debug together,
hand off the keyboard

Share a live session with a teammate and both of you see the same terminal, byte for byte. One person types at a time. Control passes with an explicit hand-off, so there's never two cursors fighting over one shell.

Need eyes from outside? Mint a public view-only link: watchers see output in real time but can't type, can't browse, and the link dies the moment you revoke it or the session ends.

  • Multi-participant shared sessions with single-controller input
  • Meet-style control hand-off between participants
  • Public view-only streams by revocable token
  • Joins and leaves go to the audit log; the asciicast is the terminal output

Put an AI agent
in the session with you

Attach a Claude-powered agent to any live session from its chat panel. It works through the same PTY you're watching: every command it runs is echoed in the terminal with a visible agent banner, captured in the recording, and written to the audit log.

The agent runs in a container on your helvi server, reaches the endpoint only through the session it's attached to, and its credentials are sealed in the vault. The agent never holds an SSH key. helvi does.

  • Claude Code or a lightweight Messages-API tool loop
  • Commands visibly injected into the shared terminal
  • Every exec audited; chat history kept per session
  • One agent can assist across many sessions at once

Built like the bastion
it replaces

The team reaches hosts through helvi.sh. Accounts, keys and the audit log are the part you have to get right.

Identity

Local accounts with argon2id hashing, or single sign-on against any OIDC provider (Okta, Entra, Keycloak, Google). Sessions are opaque and server-side, never JWTs in localStorage.

Second factor

Authenticator apps (TOTP), email and SMS codes, single-use backup codes. Make 2FA optional, required for admins, or required for everyone. Enforcement happens before the desktop loads.

Least privilege

Grants are (user or group) × endpoint folder × capability: connect, read files, write files. If it isn't granted, the API returns 403.

Secrets

Private keys and agent credentials are envelope-encrypted with age (X25519) under a boot-sealed master key. The first-run wizard makes you back it up, then never shows it again.

Accountability

Session recordings plus an append-style audit log: who signed in, who connected where, who moved which file, what every agent executed. Attribution survives shared sessions.

Small surface

One static binary, one SQLite file, no runtime dependencies to patch. Ship it behind Caddy or Traefik, health-check /healthz, done.

Install.
Open the wizard.

One Linux box is all it takes. Your data never leaves it.

curl -fsSL https://get.helvi.sh | sudo bash

Installs Docker if missing (it asks first), generates the vault passphrase into root-only /etc/helvi/helvi.env, and starts the container. Idempotent: rerun the same command any time to upgrade; your data and settings survive.

docker run -d --name helvi --restart unless-stopped \
  -p 8080:8080 -v helvi-data:/var/lib/helvi \
  keoir/helvi-sh

A ~30 MB Alpine image running as non-root. Everything (database, vault, recordings) lives in the /var/lib/helvi volume. Front it with Caddy or Traefik for TLS.

make all                          # embedded UI + static binary → bin/helvi
sudo cp bin/helvi /usr/local/bin/
sudo systemctl enable --now helvi # unit file ships in deploy/

Go ≥ 1.23 and Node ≥ 18 build the whole thing. The result is a single static binary (CGO-free, SQLite embedded) that runs anywhere Linux does.

  1. Run the installer on any Linux box with Docker: a VM, a NUC in the closet, that spare Pi-sized server.
  2. Open the wizard. First visit walks you through system checks, backing up your encryption key, and creating your org and admin account, with optional 2FA on the spot.
  3. Add your endpoints. Import SSH keys, add the hosts, grant the team access.

Your fleet is one command away
from having a desktop.

curl -fsSL https://get.helvi.sh | sudo bash