docs: changelog for v0.0.24

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,4 @@
+.git
+testenv/.keys
+testenv/.state
+testenv/.artifacts

.gitignore

@@ -19,3 +19,8 @@ dist/
 # OS
 .DS_Store
 Thumbs.db
+
+# local test environment (testenv/up.sh)
+testenv/.keys/
+testenv/.state/
+testenv/.artifacts/

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v0.0.24
+
+- Fix the `interface_name` resolver strategy: it sent filter names that NetBox ignores and therefore returned the host's first IP address instead of the named interface's. It now uses NetBox's `interface` and `vminterface` filters; a missing interface falls through to the next strategy.
+- Fix `netssh sftp` and `netssh scp` with instance-qualified hosts (`prod/web01:/path`), which were taken for local paths.
+- Fix shell aliases of instance-qualified hosts ignoring anchored rewrite rules (`fsn_fsn1-pve1` instead of `fsn_fsnpve1`).
+- Add `netssh multi` to open several hosts side by side in tmux or zellij: host lists, `tag:`, NetBox virtualization clusters (`cluster:`, devices by default, `--kind vm|all`), and groups from the config (`@name`). `--sync` sends typing to all panes; `netssh sync` toggles it later. In the TUI, `Space` marks hosts and `Enter` opens them together. Configurable in `netssh configure` (multiplexer, panes per window, groups).
+- tmux keys for broadcast in `netssh multi` windows: prefix `S` toggles all panes, prefix `e` excludes the current pane (border `[SOLO]`) or includes it again; also `netssh sync --pane`. Both keys are unbound in a default tmux, are not bound if your tmux.conf uses them, act only in netssh windows, and can be changed or turned off (`multi.sync_key`, `multi.solo_key`).
+- `netssh multi` widens the status bar of its own tmux session, which tmux otherwise cuts to `[netssh-pv`.
+- Cache entries remember the NetBox cluster of a host, for `cluster:` completion and offline use.
+- Add `testenv/`, a local Docker environment with two NetBox instances, SSH targets, a jump host, tmux, zellij, and bash/zsh/fish, and 185 end-to-end checks of all features, including `netssh multi` with real tmux and zellij and screenshot checks of what a real terminal (xterm) renders (`testenv/up.sh`, `testenv/test.sh`). Not part of CI/CD.
+
 ## v0.0.23
 
 - `netssh configure` now covers every setting: after the instances, a menu opens with SSH defaults, SSH options (jump host, host key checking, connection target, address family, extra arguments, `-o` options), SSH rules (add, edit, remove by tag, instance, kind, name pattern), resolver & cache (including the cache file), shortcuts & command alias, and completion (`max_results`). SSH options can also be set per NetBox instance from the instance list.
@@ -10,6 +21,8 @@
 - Add `netssh sftp` and `netssh scp`: host lookup, shortcuts, instances, default user and port, SSH options and rules, jump host, `--dry-run`, and completion work as for ssh. IPv6 addresses are bracketed for host:path.
 - Add named port forwards (`ssh.forwards` globally, per instance, and per rule), `netssh tunnel HOST NAME|SPEC...` (ssh -N with ExitOnForwardFailure), and `netssh --forward NAME`. Forwards are editable in `netssh configure` and completed in the shell.
 - TUI: `Ctrl+O` opens SFTP, `Ctrl+T` starts a tunnel with configured or ad hoc forwards.
+- Add the `hostname` resolver strategy: connect by the NetBox name (plus optional `resolver.hostname_domain`) instead of an IP, always or as a fallback after `primary_ip`.
+- Add static hosts (`hosts:`) for machines that are not in NetBox, with user, port, tags, and SSH options, managed with `netssh hosts list|add|remove` and in `netssh configure`. They are found before NetBox, work offline and without any NetBox, and support shortcuts, rules (`kind: static`), completion, aliases, sftp, scp, tunnels, and the TUI.
 - Fix options added by netssh landing after `--` (`netssh --no-jump -- host`), where ssh read them as the destination.
 
 ## v0.0.22

README.md

@@ -13,10 +13,26 @@ netssh -p 2222 admin@app-server-03 uptime
 
 `netssh` looks up the host in NetBox, resolves the right IP using a configurable strategy chain, and replaces the process with the native `ssh` binary — so all your existing SSH configs, keys, and agent forwarding work without any changes.
 
+The same lookup drives `netssh sftp`, `netssh scp`, and `netssh tunnel`, the interactive search, shell completion, and generated shell aliases.
+
+## Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Configuration](#configuration) — [wizard](#interactive-wizard), [manual config](#manual-config), [reference](#configuration-reference), [environment variables](#environment-variables), [files](#files-and-directories), [multiple instances](#multiple-netbox-instances)
+- [Usage](#usage) — [command overview](#command-overview), [SSH options](#ssh-options), [SFTP & SCP](#sftp-and-scp), [port forwarding](#port-forwarding), [static hosts](#static-hosts), [multiple servers](#multiple-servers-in-one-window), [shortcuts](#host-shortcuts), [TUI](#interactive-tui), [notes](#server-notes), [cache](#cache-management)
+- [Recipes](#recipes)
+- [IP Resolution Strategies](#ip-resolution-strategies)
+- [Shell Completion](#shell-completion) and [Shell Hook](#shell-hook)
+- [Troubleshooting](#troubleshooting)
+- [Uninstall](#uninstall), [Development](#development), [How it works](#how-it-works)
+
 ## Features
 
 - **Transparent proxy** — replaces itself with `ssh` via `syscall.Exec`, preserving all SSH flags and options
-- **Flexible IP resolution** — configurable chain of strategies: management subnet, primary IP, or named interface
+- **Flexible IP resolution** — configurable chain of strategies: management subnet, primary IP, named interface, or the hostname itself
+- **Static hosts** — add hosts that are not in NetBox (`netssh hosts add router 192.168.1.1`); they work everywhere, also without any NetBox
 - **Interactive TUI** — fuzzy search with live NetBox queries and 300 ms debouncing (start with `netssh`, no arguments)
 - **Recently-used list** — TUI opens with your 10 most-recently-connected hosts, no typing needed
 - **Tag/kind filter** — press `Ctrl+F` in the TUI to filter by `tag:prod` or `kind:vm`
@@ -34,6 +50,7 @@ netssh -p 2222 admin@app-server-03 uptime
 - **Automatic 24h cache refresh** — the cache is refreshed in the background every 24 hours
 - **Jump hosts and SSH options** — `proxy_jump`, host key checking, connection target, and free `-o` options per netssh, per NetBox instance, or per tag/name rule — without touching `~/.ssh/config`
 - **SFTP & SCP** — `netssh sftp host` and `netssh scp file host:/tmp/` with the same host lookup, shortcuts, and SSH options as ssh
+- **Several servers in one window** — `netssh multi` opens hosts, a tag, a NetBox cluster, or a saved group side by side in tmux or zellij, with optional typing into all of them
 - **Port forwarding** — named forwards in the config (`netssh tunnel host web`, `netssh --forward web host`), ad hoc specs, and `Ctrl+T` in the TUI
 - **Dry run** — `netssh --dry-run host` prints the final `ssh` command instead of connecting
 - **Clean uninstall** — `netssh uninstall` removes the binary, profile entries of all versions, completions, cache, and config
@@ -97,6 +114,22 @@ cd ssh-netbox-wrapper
 go build -o netssh ./cmd/netssh
 ```
 
+## Quick start
+
+1. **Install** with the one-liner above and open a new terminal.
+2. **Configure** — run `netssh` (or `netssh configure`). The wizard asks for your NetBox URL and an API token; a read-only token is enough unless you want to edit NetBox comments. Everything else has working defaults and can be changed later.
+3. **Fill the cache** — `netssh cache refresh` fetches all devices and virtual machines once. Connecting works without it, but completion, shortcuts, aliases, and the recently-used list need cached hosts.
+4. **Connect** — `netssh web01`, or just `netssh` for the interactive search.
+5. **Optional** — enable completion and aliases with `netssh hook install` (the installer usually did this already), and try `netssh --dry-run web01` to see the exact ssh command.
+
+```sh
+netssh configure                 # NetBox URL + token
+netssh cache refresh             # fetch all hosts once
+netssh web01                     # ssh to web01 via its NetBox IP
+netssh sftp web01                # sftp to the same host
+netssh tunnel web01 8080:localhost:80   # local port 8080 → web01:80
+```
+
 ## Configuration
 
 ### Interactive wizard
@@ -108,7 +141,7 @@ Re-run it at any time to change settings without editing the file manually:
 netssh configure
 ```
 
-The wizard first lets you add, edit, and remove named NetBox instances and set SSH options per instance.
+The wizard first lets you add, edit, and remove named NetBox instances and set SSH options per instance. Without any instance you can also continue with static hosts only.
 A menu then gives access to every other setting; open only the sections you want to change and choose **Save and exit**:
 
 | Section | Settings |
@@ -116,7 +149,9 @@ A menu then gives access to every other setting; open only the sections you want
 | SSH defaults | `ssh.default_user`, `ssh.default_port` |
 | SSH options | `proxy_jump`, `host_key_checking`, `target`, `address_family`, `extra_args` (one per line), `options` (`Key=Value` per line), `forwards` (`NAME L\|R\|D SPEC` per line) |
 | SSH rules | add, edit, remove `ssh.rules` — match by tag, instance, kind, name pattern, each with its own SSH options |
-| Resolver & cache | strategies, management subnets, interface name, cache TTL, cache file |
+| Static hosts | add, edit, remove hosts that are not in NetBox, each with user, port, tags, and SSH options |
+| Multi-session | multiplexer (auto, tmux, zellij), panes per window, tmux keys for broadcast and excluding a pane, groups (`NAME: sel1, sel2` per line) |
+| Resolver & cache | strategies, management subnets, interface name, hostname domain, cache TTL, cache file |
 | Shortcuts & command alias | domain suffixes, hyphen stripping, rewrite rules (`REGEX => REPLACEMENT` per line), `shell.alias` |
 | Completion | `completion.max_results` |
 
@@ -163,7 +198,79 @@ shortcuts:
   strip_hyphens: false # if true, fsn1-web01 → fsn1web01 (cache-only resolution)
 ```
 
-Single-instance and shared settings can be overridden with environment variables (`NETSSH_NETBOX_URL`, `NETSSH_NETBOX_TOKEN`, etc.).
+Single-instance and shared settings can be overridden with environment variables (`NETSSH_NETBOX_URL`, `NETSSH_NETBOX_TOKEN`, etc.; see [Environment variables](#environment-variables)).
+
+netssh reads `netssh.yaml` from the user config directory and, if none exists there, from the current working directory. Unknown keys are ignored; invalid values (an unknown strategy, a bad regex, an invalid SSH option) stop netssh with an error that names the key.
+
+### Configuration reference
+
+Every key, its default, and the section that explains it. Keys marked *layered* can also be set per NetBox instance (`netboxes[].ssh.…`) and per rule (`ssh.rules[].…`).
+
+| Key | Type | Default | Description |
+|---|---|---|---|
+| `netbox.url` | string | — | NetBox base URL (single instance). Use either `netbox` or `netboxes`. |
+| `netbox.token` | string | — | API token; `nbt_…` is v2, anything else v1. |
+| `netbox.token_version` | 1 \| 2 | auto | Detected from the token prefix. |
+| `netboxes[]` | list | — | Named instances with `name`, `url`, `token`, `token_version`, `ssh` — see [Multiple NetBox instances](#multiple-netbox-instances). |
+| `resolver.strategies` | list | `[management_subnet, primary_ip]` | Tried in order, first IP wins — see [IP Resolution Strategies](#ip-resolution-strategies). The wizard suggests `primary_ip`. |
+| `resolver.management_subnets` | list of CIDR | `[]` | Used by `management_subnet`. |
+| `resolver.interface_name` | string | — | Used by `interface_name`, e.g. `mgmt0`. |
+| `resolver.hostname_domain` | string | — | Used by `hostname`: appended to NetBox names without a dot. |
+| `cache.ttl` | seconds | `3600` | How long a cached IP is used without asking NetBox; `0` always asks NetBox when connecting. |
+| `cache.path` | path | user cache dir `/netssh/hosts.json` | Cache file; named instances use a subdirectory next to it. |
+| `ssh.default_user` | string | — | Login user when none is given (`-l` for ssh, `-o User=` for sftp/scp). |
+| `ssh.default_port` | int | — | Port when none is given (`-p` for ssh, `-P` for sftp/scp). |
+| `ssh.proxy_jump` | string | — | *Layered.* Jump host (`-J`); `none` disables an inherited one. |
+| `ssh.host_key_checking` | `strict` \| `accept-new` \| `off` | ssh's own | *Layered.* See [SSH options](#ssh-options). |
+| `ssh.target` | `ip` \| `name` \| `hostname` | `ip` | *Layered.* What is passed to ssh as destination. |
+| `ssh.address_family` | `any` \| `inet` \| `inet6` | — | *Layered.* `-o AddressFamily=`. |
+| `ssh.extra_args` | list | `[]` | *Layered.* Extra ssh arguments; accumulate across layers; ssh only. |
+| `ssh.options` | map | `{}` | *Layered.* `-o Key=Value`; per key, the more specific layer wins. |
+| `ssh.forwards` | map | `{}` | *Layered.* Named port forwards (`local`, `remote`, `dynamic`) — see [Port forwarding](#port-forwarding). |
+| `ssh.rules[]` | list | `[]` | `match` (`tag`, `instance`, `kind`, `name`) plus any layered key. |
+| `shortcuts.domains` | list | `[]` | Suffixes stripped for shortcuts and tried when expanding a short name. |
+| `shortcuts.strip_hyphens` | bool | `false` | Ignore hyphens when matching shortcuts. |
+| `shortcuts.rewrites[]` | list | `[]` | `pattern` (Go regex) and `replace` — see [Host shortcuts](#host-shortcuts). |
+| `completion.max_results` | int | `0` | Hostnames offered per `<Tab>`; `0` = unlimited. |
+| `shell.alias` | string | — | Short command name for netssh, e.g. `j` — see [Short command alias](#short-command-alias). |
+| `hosts[]` | list | `[]` | Static hosts with `name`, `address`, `user`, `port`, `tags`, `ssh` — see [Static hosts](#static-hosts). |
+| `groups` | map of lists | `{}` | Named host lists for `netssh multi @NAME`; entries are hosts or selectors. |
+| `multi.multiplexer` | `auto` \| `tmux` \| `zellij` | `auto` | Which multiplexer `netssh multi` uses. |
+| `multi.panes_per_window` | int | `9` | More hosts open in further tmux windows or zellij tabs. |
+| `multi.sync_key`, `multi.solo_key` | tmux key \| `none` | `S`, `e` | Keys after the tmux prefix: broadcast to all panes, exclude/include the current pane. |
+
+### Environment variables
+
+These variables override the file. Lists are comma-separated (`NETSSH_SHORTCUTS_DOMAINS=.example.com,.example.de`). Settings without a variable (`extra_args`, `options`, `forwards`, `rules`, `rewrites`, `netboxes`, `hosts`, `groups`) can only be set in the file.
+
+| Variable | Key |
+|---|---|
+| `NETSSH_NETBOX_URL`, `NETSSH_NETBOX_TOKEN`, `NETSSH_NETBOX_TOKEN_VERSION` | `netbox.*` (single instance only; ignored when the file has only `netboxes:`) |
+| `NETSSH_RESOLVER_STRATEGIES`, `NETSSH_RESOLVER_MANAGEMENT_SUBNETS`, `NETSSH_RESOLVER_INTERFACE_NAME`, `NETSSH_RESOLVER_HOSTNAME_DOMAIN` | `resolver.*` |
+| `NETSSH_CACHE_TTL`, `NETSSH_CACHE_PATH` | `cache.*` |
+| `NETSSH_SSH_DEFAULT_USER`, `NETSSH_SSH_DEFAULT_PORT` | `ssh.default_*` |
+| `NETSSH_SSH_PROXY_JUMP`, `NETSSH_SSH_HOST_KEY_CHECKING`, `NETSSH_SSH_TARGET`, `NETSSH_SSH_ADDRESS_FAMILY` | global `ssh.*` options |
+| `NETSSH_SHORTCUTS_DOMAINS`, `NETSSH_SHORTCUTS_STRIP_HYPHENS` | `shortcuts.*` |
+| `NETSSH_COMPLETION_MAX_RESULTS` | `completion.max_results` |
+| `NETSSH_MULTI_MULTIPLEXER`, `NETSSH_MULTI_PANES_PER_WINDOW` | `multi.*` |
+| `NETSSH_SHELL_ALIAS` | `shell.alias` |
+
+netssh also respects `XDG_CONFIG_HOME`, `XDG_CACHE_HOME`, `ZDOTDIR`, and `SHELL` (for `hook install`, `completion install`, and `alias` without `--shell`).
+
+### Files and directories
+
+Paths are shown for Linux, where `XDG_CONFIG_HOME` and `XDG_CACHE_HOME` replace `~/.config` and `~/.cache`. On macOS, config and notes live under `~/Library/Application Support`, the host cache and `aliases.sh` under `~/Library/Caches/netssh/` (unless `XDG_CACHE_HOME` is set for `aliases.sh`); fish and completion files use the paths in the table.
+
+| Path | Content |
+|---|---|
+| `~/.config/netssh.yaml` | Configuration, including API tokens; written with mode `0600`. |
+| `~/.config/netssh/notes/` | Local server notes (`0600`), keyed by NetBox URL, kind, and hostname. |
+| `~/.cache/netssh/hosts.json` | Host cache (single instance). |
+| `~/.cache/netssh/instances-<hash>/hosts.json` | Host cache for a set of named instances; the hash changes when names or URLs change. |
+| `~/.cache/netssh/last_refresh` | Time of the last full refresh, for the 24-hour background refresh. |
+| `~/.cache/netssh/aliases.sh` | Generated aliases for bash and zsh. |
+| `~/.config/fish/conf.d/netssh.fish` | Generated aliases for fish. |
+| `~/.local/share/bash-completion/completions/netssh`, `~/.zfunc/_netssh`, `~/.config/fish/completions/netssh.fish` | Installed completions. |
 
 ### Multiple NetBox instances
 
@@ -249,6 +356,30 @@ A hint is shown during `netssh configure` if a legacy v1 token is entered.
 
 ## Usage
 
+### Command overview
+
+| Command | Purpose |
+|---|---|
+| `netssh` | Interactive search (TUI). |
+| `netssh [--dry-run] [--jump HOST\|--no-jump] [--forward NAME]... [ssh options] HOST [command]` | Connect with ssh. |
+| `netssh sftp [netssh flags] [sftp options] HOST[:PATH]` | SFTP session — see [SFTP and SCP](#sftp-and-scp). |
+| `netssh scp [netssh flags] [scp options] SOURCE... TARGET` | Copy files — see [SFTP and SCP](#sftp-and-scp). |
+| `netssh tunnel [netssh flags] [ssh options] HOST FORWARD...` | Port forwards without a shell — see [Port forwarding](#port-forwarding). |
+| `netssh hosts [list] \| add NAME ADDRESS [--user U] [--port P] [--tag T]... [--replace] \| remove NAME` | Manage static hosts — see [Static hosts](#static-hosts). |
+| `netssh multi [--sync] [--kind K] [--tmux\|--zellij] [-l U] [--jump H\|--no-jump] HOST\|tag:T\|cluster:C\|@GROUP...` | Several hosts side by side — see [Multiple servers](#multiple-servers-in-one-window). |
+| `netssh sync [--pane]` | Toggle typing into all panes of the current tmux window or zellij tab; `--pane` excludes/includes the current tmux pane. |
+| `netssh configure` | Setup wizard. |
+| `netssh cache list \| refresh [--tag T] [--kind device\|vm] [--instance I] \| clear` | Inspect and manage the host cache. |
+| `netssh search QUERY` | Print matching cached hostnames, one per line. |
+| `netssh alias [--shell bash\|zsh\|fish] [--test HOSTNAME]` | Print shell aliases, or test how a name is shortened. |
+| `netssh notes show\|set\|append HOST [TEXT] [--netbox] [--kind device\|vm]` | Local notes or NetBox comments. |
+| `netssh hook install\|uninstall [--shell S]` | Shell integration (aliases, completion, background refresh). |
+| `netssh completion install [--shell S]` / `netssh completion bash\|zsh\|fish` | Install or print completion scripts. |
+| `netssh uninstall [--dry-run] [--keep-config] [--yes]` | Remove netssh. |
+| `netssh version` / `netssh --version` | Print the version. |
+
+The netssh flags `--dry-run`, `--jump`, `--no-jump`, and `--forward` must come before the host. Everything after the host is passed to ssh as the remote command (for `tunnel`: forward names).
+
 ### SSH wrapper mode
 
 Pass any SSH flags and a NetBox hostname:
@@ -329,6 +460,30 @@ With `target: hostname`, ssh resolves the NetBox name itself (DNS or
 Switching to `name` stores new known_hosts entries under the device name, so
 ssh asks once to confirm each host key.
 
+**Rules.** A rule applies when every field set in its `match` fits the host:
+
+| Match field | Compared with | Notes |
+|---|---|---|
+| `tag` | NetBox tags of the host | Tag name or slug, case-insensitive (`DMZ Hosts` matches `dmz-hosts`). |
+| `instance` | Name of the NetBox instance | Only useful with `netboxes:`. |
+| `kind` | `device`, `vm`, or `static` | Devices come from DCIM, VMs from Virtualization, `static` from `hosts:`. |
+| `name` | Hostname without instance prefix | Shell glob, case-insensitive (`*.dmz.example.com`, `fw-??`). |
+
+Tags and kind are taken from the cache or the NetBox answer, so rules work offline for cached hosts. A rule needs at least one match field. All matching rules apply in file order; a later rule overrides an earlier one.
+
+**How layers combine.** netssh merges global → instance (or the static host's own `ssh`) → matching rules:
+
+- single values (`proxy_jump`, `host_key_checking`, `target`, `address_family`) — the most specific non-empty value wins;
+- `options` and `forwards` — merged per key or name, the more specific layer wins;
+- `extra_args` — collected from all layers.
+
+Options you type yourself always win: netssh adds its `-o` options after yours, and ssh uses the first value it sees; `-J`, `-4`/`-6`, or your own `StrictHostKeyChecking` suppress the matching setting. Check the result with `--dry-run`:
+
+```sh
+$ netssh --dry-run fw01.dmz.example.com
+ssh -A -l admin -J dmz-jump.example.com -o StrictHostKeyChecking=accept-new -o serveraliveinterval=60 192.0.2.10
+```
+
 ### SFTP and SCP
 
 `netssh sftp` and `netssh scp` look up the host exactly like a connection does: cache, shortcuts and rewrite rules, `instance/host`, default user and port, SSH options and rules, `--jump`/`--no-jump`, and `--dry-run`.
@@ -367,7 +522,86 @@ netssh --forward web fsnbx1               # shell plus forward (repeatable)
 
 A value that is no configured name but a port spec (`[bind:]port:host:hostport`) becomes a local forward. `netssh tunnel` adds `-o ExitOnForwardFailure=yes`, so a port already in use fails instead of leaving a silent session. Without forward names it lists the forwards configured for the host. Forward names are completed after the host (`netssh tunnel fsnbx1 <Tab>`) and after `--forward`. In the TUI, `Ctrl+T` on a host opens an input with its configured forwards.
 
-`sftp`, `scp`, and `tunnel` are subcommands; to connect to a host with one of these names, use `netssh -- sftp`.
+`sftp`, `scp`, `tunnel`, `hosts`, `multi`, and `sync` are subcommands; to connect to a host with one of these names, use `netssh -- sftp`.
+
+### Static hosts
+
+Hosts that are not in NetBox — a home router, a cloud VM, a customer machine — can be added to the config. netssh checks them before NetBox, so they work offline and even without any NetBox configured.
+
+```sh
+netssh hosts add router 192.168.1.1 --user admin --tag home
+netssh hosts add backup backup.example.org --port 2222 --tag offsite
+netssh hosts                      # list
+netssh hosts add router 192.168.1.254 --replace   # change the address, keep its SSH options
+netssh hosts remove backup
+```
+
+The same in the config (or in `netssh configure` → *Static hosts*):
+
+```yaml
+hosts:
+  - name: router
+    address: 192.168.1.1          # IP address or DNS name
+    user: admin                   # optional, overrides ssh.default_user
+    port: 2222                    # optional, overrides ssh.default_port
+    tags: [home]                  # optional, for ssh.rules
+    ssh:                          # optional, same keys as ssh: (proxy_jump, options, forwards, …)
+      proxy_jump: none
+```
+
+Static hosts behave like NetBox hosts everywhere: `netssh router`, `sftp`, `scp`, `tunnel`, shortcuts and rewrite rules, Tab completion, shell aliases, the TUI search and its recently-used list, and `ssh.rules` (match `kind: static` or their tags). Their SSH options are merged like an instance's: global → static host → rules. User and port on the command line still win.
+
+- Names may contain letters, digits, dots, underscores, and hyphens, and are matched case-insensitively. They have no instance prefix.
+- A static host wins over a NetBox host of the same name. Give them distinct names to keep both reachable.
+- Static hosts never expire and are not touched by `cache refresh` or `cache clear`; removing one from the config removes it everywhere.
+- `--netbox` notes and NetBox comments are not available for static hosts; local notes work.
+
+### Multiple servers in one window
+
+`netssh multi` opens one pane per host in tmux or zellij — for example every node of a Proxmox or Kubernetes cluster — and can send your typing to all of them at once.
+
+```sh
+netssh multi web01 web02 db01              # hosts, shortcuts, instance/host, static hosts
+netssh multi tag:k8s-worker                # all hosts with a NetBox tag (and static hosts with it)
+netssh multi cluster:pve-fsn1              # the devices (nodes) of a NetBox virtualization cluster
+netssh multi --kind vm cluster:pve-fsn1    # the cluster's VMs; --kind all for both
+netssh multi @k8s                          # a saved group
+netssh multi --sync @k8s                   # start with typing sent to every pane
+netssh multi --dry-run cluster:pve-fsn1    # show the hosts and tmux/zellij commands
+```
+
+Each pane runs `netssh HOST`, so lookup, shortcuts, user and port, jump hosts, and rules work as for a single connection. `-l USER`, `--jump HOST`, and `--no-jump` apply to every pane. A pane whose connection fails stays open with the error until you press Enter.
+
+**Groups** collect hosts and selectors under a name (or use `netssh configure` → *Multi-session*):
+
+```yaml
+groups:
+  k8s: [k8s-master1, "tag:k8s-worker"]
+  pve: ["cluster:pve-fsn1"]
+  all-web: ["@k8s", "tag:web", legacy-box]
+multi:
+  multiplexer: auto        # auto | tmux | zellij
+  panes_per_window: 9      # more hosts open in further windows/tabs
+  sync_key: S              # tmux: prefix S = broadcast on/off (none = no key)
+  solo_key: e              # tmux: prefix e = exclude/include this pane
+```
+
+**tmux and zellij.** With `auto`, netssh uses the multiplexer you are in; otherwise tmux, then zellij, whichever is installed (`--tmux` / `--zellij` choose explicitly).
+
+| | tmux | zellij |
+|---|---|---|
+| Inside a session | new window in the current session | new tab in the current session |
+| Outside | new session `netssh-NAME`, attached | new session from a generated layout |
+| Layout | tiled; pane borders show the host | grid; pane titles show the host |
+| Broadcast to all panes | `--sync`; toggle with `Ctrl+b S` or `netssh sync` | `--sync` inside zellij; toggle with `Ctrl+t` then `s` or `netssh sync` |
+| Exclude one pane | `Ctrl+b e` (again: include) or `netssh sync --pane` | not possible — zellij syncs whole tabs |
+| Shown in the border | `[SYNC]` receives broadcast, `[SOLO]` excluded | `(SYNC)` in the tab name |
+
+**Keys in tmux.** `S` and `e` are free in a default tmux (`E` would be "spread panes evenly"). netssh binds them after your prefix when it opens panes, but only if your own `tmux.conf` does not already use them — then it keeps your binding and says so. They act only in windows opened by `netssh multi`; elsewhere they just show a message. Change or turn them off with `multi.sync_key` / `multi.solo_key` (`none`), e.g. `sync_key: C-s` for `prefix Ctrl+s`.
+
+**In the TUI**, mark hosts with `Space` (or all listed hosts with `Ctrl+A`) and press `Enter` to open them together.
+
+`tag:` and `cluster:` ask NetBox (all instances); if NetBox is unreachable, netssh uses the cached hosts and prints a warning. More than 24 hosts need `--yes`. The 24-hour background cache refresh runs once, not in every pane.
 
 ### Default username
 
@@ -486,6 +720,8 @@ The TUI opens with your 10 most-recently-connected hosts. Start typing to search
 | `Tab` | autocomplete top result into the search field |
 | `↑` / `↓` | navigate results |
 | `Enter` | connect to selected host |
+| `Space` | mark/unmark the host; with marks, `Enter` opens them side by side (`netssh multi`) |
+| `Ctrl+A` | mark all listed hosts (again: unmark all) |
 | `Ctrl+O` | open an SFTP session to the selected host |
 | `Ctrl+T` | start a tunnel: enter forward names or specs (`web, 8080:localhost:80`) |
 | `Ctrl+E` | open inline editor to override user/port before connecting |
@@ -581,6 +817,96 @@ The hook is a no-op when the cache is fresh — it adds no measurable delay to y
 netssh search app-           # prints matching hostnames, one per line
 ```
 
+## Recipes
+
+**Everything through a bastion, except the bastion itself**
+
+```yaml
+ssh:
+  proxy_jump: admin@bastion.example.com
+  rules:
+    - match: {name: "bastion*"}
+      proxy_jump: none
+```
+
+**A different jump host per site (NetBox instance)**
+
+```yaml
+netboxes:
+  - name: fsn
+    url: https://netbox.fsn.example.com
+    token: nbt_…
+    ssh: {proxy_jump: jump.fsn.example.com}
+  - name: hel
+    url: https://netbox.hel.example.com
+    token: nbt_…
+    ssh: {proxy_jump: jump.hel.example.com}
+```
+
+**Lab machines that are reinstalled every day**
+
+```yaml
+ssh:
+  rules:
+    - match: {instance: lab}
+      host_key_checking: off      # prints a notice on every connection
+```
+
+**Database and web tunnels by tag**
+
+```yaml
+ssh:
+  forwards:
+    socks: {dynamic: "1080"}                # browser via SOCKS on localhost:1080
+  rules:
+    - match: {tag: postgres}
+      forwards: {db: {local: "5432:localhost:5432"}}
+    - match: {tag: grafana}
+      forwards: {web: {local: "3000:localhost:3000"}}
+```
+
+```sh
+netssh tunnel db01 db          # psql -h localhost then reaches db01
+netssh tunnel grafana01 web socks
+```
+
+**Short names for a hosting naming scheme** (`fsn1-bx1.hoster.de` → `fsnbx1`)
+
+```yaml
+shortcuts:
+  domains: [.hoster.de]
+  rewrites:
+    - pattern: '^([a-z]+)[0-9]+-'
+      replace: '$1'
+```
+
+```sh
+netssh cache refresh && netssh alias --test fsn1-bx1.hoster.de
+netssh fsnbx1                   # also works as shell alias: fsnbx1
+```
+
+**Maintenance on all nodes of a cluster at once**
+
+```sh
+netssh multi --sync cluster:pve-fsn1     # every node in one window, typing goes to all
+# … run apt upgrade on all nodes; Ctrl+b e on a node that needs something
+# different excludes just that one, Ctrl+b S turns broadcast off for all
+```
+
+**Deploy a file and restart a service**
+
+```sh
+netssh scp ./app.tar prod/app01:/tmp/ && netssh prod/app01 'sudo systemctl restart app'
+```
+
+**Use netssh in scripts**
+
+```sh
+for host in $(netssh search web-); do
+  netssh "$host" uptime
+done
+```
+
 ## IP Resolution Strategies
 
 Strategies are tried in the configured order; the first to succeed wins.
@@ -592,6 +918,22 @@ Cache refresh uses the same strategies as a direct connection. To allow the prim
 | `primary_ip` | Returns the `primary_ip4` (or `primary_ip6`) set in NetBox. No extra API call. |
 | `management_subnet` | Fetches all IPs for the host and returns the first one matching a configured CIDR. |
 | `interface_name` | Fetches IPs attached to a specific named interface (e.g. `mgmt0`). |
+| `hostname` | Uses the NetBox name instead of an IP, with `resolver.hostname_domain` appended to names without a dot. DNS or `~/.ssh/config` resolves it when ssh connects. No extra API call. |
+
+**`hostname` strategy.** Its position in the chain decides when it applies:
+
+```yaml
+resolver:
+  strategies: [primary_ip, hostname]   # IP if NetBox has one, otherwise the hostname
+  hostname_domain: example.com         # web01 → web01.example.com
+```
+
+```yaml
+resolver:
+  strategies: [hostname]               # always connect by name, never by IP
+```
+
+Names that are not valid DNS hostnames (spaces, underscores) are skipped, so the next strategy is tried. The cache then stores the name instead of an IP, and `--dry-run` shows `ssh web01.example.com`. Compared with `ssh.target: hostname`, the strategy works as a fallback for hosts without an IP in NetBox and can be combined with `target: name`.
 
 ## Shell Completion
 
@@ -728,6 +1070,32 @@ The shell hook and the connect-time trigger (which fires on each `netssh` invoca
 
 Both are non-blocking — the refresh runs as a background process and never delays your prompt or SSH connection. They share `~/.cache/netssh/last_refresh`, so only one background refresh runs per 24-hour window regardless of how many shells or connections are opened.
 
+## Troubleshooting
+
+**See what netssh would run.** `--dry-run` works for ssh, `sftp`, `scp`, and `tunnel` and prints the final command with the resolved IP and all added options.
+
+| Message / symptom | Cause and fix |
+|---|---|
+| `host not found` | The name is not in NetBox (devices and VMs are searched). Check the spelling, or configure `shortcuts.domains` if you type short names. |
+| `host "x" is not in hosts: and no NetBox is configured` | Only static hosts are configured. Add the host with `netssh hosts add`, or a NetBox with `netssh configure`. |
+| `no strategy resolved an IP` | No resolver strategy found an address. Add `primary_ip` or `hostname` as a fallback at the end of `resolver.strategies`. |
+| `ambiguous shortcut "x"; use a full hostname` | Several cached hosts shorten to the same name. Use the full name, or check with `netssh alias --test`. |
+| `found 2 exact matches` | The name exists in several NetBox instances, or as both device and VM. Prefix the instance (`prod/web01`); for notes and the TUI also `--kind`. |
+| Shortcut works for one host but not another | Shortcuts (hyphen folding, rewrites) only match cached hosts. Run `netssh cache refresh`. |
+| Connection fails although a NetBox instance is down | Without an instance prefix, every instance must answer to rule out duplicates. Use `instance/host`; a fresh cache entry then needs no NetBox at all. |
+| Wrong or outdated IP | Lower `cache.ttl`, run `netssh cache refresh`, and check the [strategy order](#ip-resolution-strategies). |
+| `REMOTE HOST IDENTIFICATION HAS CHANGED` | The host was reinstalled or the IP reused. Remove the old key (`ssh-keygen -R <ip>`), consider `target: name`, or for lab hosts `host_key_checking: off`. |
+| `unknown forward "x"` | The name is not configured for this host (forwards can be per instance or rule). The message lists the available ones. |
+| `bind [127.0.0.1]:8080: Address already in use` | The local port of a forward is taken; `netssh tunnel` then exits instead of hanging. Choose another port. |
+| Saving notes with `--netbox` fails with a permission error | The API token is read-only. Local notes work without write permission. |
+| `<Tab>` completes files instead of hosts | Run `netssh completion install` and open a new terminal; for zsh also `rm -f ~/.zcompdump*`. |
+| Aliases missing in a new shell | `netssh hook install`, then a new terminal. The cache must not be empty. |
+| A host is named `sftp`, `scp`, `tunnel`, `hosts`, `multi`, `sync`, or like another subcommand | Use `netssh -- sftp`. |
+| `netssh multi needs tmux or zellij` | Install one of them (`apt install tmux`, `brew install tmux`). |
+| zellij shows empty boxes in its tab and status bar | Those are Powerline arrows; use a Nerd Font in your terminal, or add `simplified_ui true` to `~/.config/zellij/config.kdl`. |
+| `cluster:x matches no hosts` | Clusters select devices by default; VMs need `--kind vm` or `--kind all`. The name is matched case-insensitively. |
+| `netssh multi` panes use another config | Inside an existing tmux/zellij session, panes get your `HOME` and `XDG_*` paths, but not `NETSSH_*` variables (they would be visible to other users in the process list). Put such settings in the config file. |
+
 ## Uninstall
 
 ```sh
@@ -757,7 +1125,32 @@ go test ./...        # includes offline installer/update tests
 go build ./...       # build all packages
 ```
 
-The test suite covers the cache, NetBox client (via `httptest`), IP resolver chain, SSH argument parser, config loading, setup wizard, shortcut normalization, and shell hook install/uninstall.
+End-to-end tests run against real services in a local Docker environment — two NetBox instances, SSH targets on separate networks, a jump host, an IPv6 host, tmux, zellij, and bash/zsh/fish. See [testenv/README.md](testenv/README.md). It is not part of CI/CD.
+
+```sh
+testenv/up.sh        # build and start (first start ~6 min)
+testenv/test.sh      # 185 checks: connect, strategies, instances, shortcuts, rules, sftp/scp, tunnels, notes, shells, TUI, configurator, multi with tmux and zellij, and what xterm renders (screenshots + OCR)
+testenv/down.sh
+```
+
+The test suite covers the cache, NetBox client (via `httptest`), IP resolver chain, the argument parsers for ssh, sftp, and scp, SSH options and rules, port forwards, config loading, the setup wizard, shortcut normalization and rewrites, completion, the TUI keys, and shell hook install/uninstall. Wrapper tests run the real command (`sftp`, `scp`, `tunnel` with `--dry-run`) in a subprocess against a pre-filled cache, so no NetBox or ssh server is needed.
+
+Project layout:
+
+| Directory | Content |
+|---|---|
+| `cmd/netssh` | Commands, host resolution, completion. |
+| `internal/config` | Config loading, validation, SSH option layering. |
+| `internal/netbox` | NetBox API client, multiple instances. |
+| `internal/resolver` | IP resolution strategies. |
+| `internal/cache` | Host cache. |
+| `internal/ssh` | Argument parsing and option injection for ssh, sftp, scp. |
+| `internal/multiplex` | tmux and zellij layouts for `netssh multi`. |
+| `internal/shortcuts` | Shortcut normalization. |
+| `internal/tui` | Interactive search. |
+| `internal/setup` | Setup wizard. |
+| `internal/hook` | Shell hooks, aliases, completion files. |
+| `internal/notes` | Local notes and NetBox comments. |
 
 ## Disclaimer
 
@@ -765,9 +1158,10 @@ This is a **vibe-coded** project: the entire codebase — architecture, implemen
 
 ## How it works
 
-1. `netssh` checks whether the first argument is a known subcommand (`configure`, `search`, `cache`, `completion`, `version`, `uninstall`, …). If not, it enters SSH wrapper mode.
-2. On first run or when `netbox.url` is empty, the interactive setup wizard starts automatically.
-3. It parses the SSH arguments to extract the destination hostname, handling all flags that consume an extra argument (`-p`, `-i`, `-J`, …).
-4. It resolves the destination: first an exact cache lookup, then shortcut expansion (domain append, hyphen folding) against the cache, and finally a fresh NetBox query with the expanded name. If the cache entry is within the TTL, no network request is made.
-5. Otherwise it queries NetBox (`/api/dcim/devices/` and `/api/virtualization/virtual-machines/` in parallel), runs the result through the resolver chain, and caches the IP.
-6. It adds the configured SSH options for the host (jump host, host key checking, `-o` options) before the destination and calls `syscall.Exec` to replace itself with `ssh`, substituting the hostname with the resolved IP (or the name, with `ssh.target: name`).
+1. `netssh` checks whether the first argument is a known subcommand (`configure`, `cache`, `sftp`, `scp`, `tunnel`, `multi`, `notes`, …). If not, it enters SSH wrapper mode; without arguments it starts the TUI.
+2. On first run, or when neither a NetBox nor static hosts are configured, the interactive setup wizard starts automatically.
+3. It removes its own long options (`--dry-run`, `--jump`, `--no-jump`, `--forward`) and parses the remaining arguments with the flag table of the program it will run (ssh, sftp, or scp differ, e.g. in `-l` and `-P`) to find the destination: `[user@]host` for ssh, `[user@]host[:path]` for sftp, and every `host:path` operand for scp.
+4. It resolves the host: first the static hosts from `hosts:` (by name or shortcut), then an exact cache lookup, a shortcut match against the cache (domains, rewrites, hyphen folding), and finally NetBox (`/api/dcim/devices/` and `/api/virtualization/virtual-machines/`, all instances in parallel) with the resolver chain. A fresh cache entry needs no network request; new results are cached.
+5. It adds the user and port (a static host's own, else the defaults) in the program's syntax unless you gave your own.
+6. It merges the SSH options for the host (global, instance, matching rules), resolves named forwards, and inserts the options before the first operand: jump host, host key checking, `-o` options, forwards, and for `tunnel` `-N` with `ExitOnForwardFailure`.
+7. It replaces the hostname with the resolved IP (or the name, with `ssh.target: name`; IPv6 in brackets for sftp/scp) and calls `syscall.Exec` to become `ssh`, `sftp`, or `scp` — or prints the command with `--dry-run`.

cmd/netssh/hosts.go

@@ -0,0 +1,142 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/setup"
+)
+
+func hostsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "hosts",
+		Short: "Manage static hosts that are not in NetBox",
+		Long: `Static hosts are defined under hosts: in the config. They are found before
+NetBox, work offline, and support shortcuts, rules (kind: static), aliases,
+completion, sftp, scp, and tunnels like NetBox hosts.`,
+		RunE: func(cmd *cobra.Command, args []string) error { return listHosts() },
+	}
+	cmd.AddCommand(hostsListCmd(), hostsAddCmd(), hostsRemoveCmd())
+	return cmd
+}
+
+func hostsListCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "list",
+		Short: "List static hosts",
+		RunE:  func(cmd *cobra.Command, args []string) error { return listHosts() },
+	}
+}
+
+func listHosts() error {
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+	if len(cfg.Hosts) == 0 {
+		fmt.Println("No static hosts. Add one with: netssh hosts add NAME ADDRESS")
+		return nil
+	}
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	fmt.Fprintln(w, "NAME\tADDRESS\tUSER\tPORT\tTAGS")
+	for _, host := range cfg.Hosts {
+		port := ""
+		if host.Port > 0 {
+			port = fmt.Sprint(host.Port)
+		}
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", host.Name, host.Address, host.User, port, strings.Join(host.Tags, ","))
+	}
+	return w.Flush()
+}
+
+func hostsAddCmd() *cobra.Command {
+	var host config.StaticHost
+	var replace bool
+	cmd := &cobra.Command{
+		Use:   "add NAME ADDRESS",
+		Short: "Add a static host (or replace one with --replace)",
+		Example: `  netssh hosts add router 192.168.1.1 --user admin
+  netssh hosts add backup backup.example.org --port 2222 --tag offsite`,
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg, err := config.Load()
+			if err != nil {
+				return err
+			}
+			host.Name, host.Address = args[0], args[1]
+			if existing := cfg.StaticHost(host.Name); existing != nil {
+				if !replace {
+					return fmt.Errorf("static host %q already exists; use --replace to overwrite it", existing.Name)
+				}
+				host.SSH = existing.SSH // keep SSH options set in the config or wizard
+				*existing = host
+			} else {
+				cfg.Hosts = append(cfg.Hosts, host)
+			}
+			return saveHosts(cfg)
+		},
+	}
+	cmd.Flags().StringVar(&host.User, "user", "", "Login user (default: ssh.default_user)")
+	cmd.Flags().IntVar(&host.Port, "port", 0, "SSH port (default: ssh.default_port or 22)")
+	cmd.Flags().StringSliceVar(&host.Tags, "tag", nil, "Tag for ssh.rules (repeatable)")
+	cmd.Flags().BoolVar(&replace, "replace", false, "Overwrite an existing static host")
+	return cmd
+}
+
+func hostsRemoveCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:     "remove NAME",
+		Aliases: []string{"rm"},
+		Short:   "Remove a static host",
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg, err := config.Load()
+			if err != nil {
+				return err
+			}
+			for i, host := range cfg.Hosts {
+				if strings.EqualFold(host.Name, args[0]) {
+					cfg.Hosts = append(cfg.Hosts[:i], cfg.Hosts[i+1:]...)
+					return saveHosts(cfg)
+				}
+			}
+			return fmt.Errorf("no static host %q", args[0])
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+			cfg, err := config.Load()
+			if err != nil || len(args) > 0 {
+				return nil, cobra.ShellCompDirectiveNoFileComp
+			}
+			var names []string
+			for _, host := range cfg.Hosts {
+				if strings.HasPrefix(strings.ToLower(host.Name), strings.ToLower(toComplete)) {
+					names = append(names, host.Name)
+				}
+			}
+			return names, cobra.ShellCompDirectiveNoFileComp
+		},
+	}
+}
+
+// saveHosts writes the config and regenerates the shell aliases.
+func saveHosts(cfg *config.Config) error {
+	if err := setup.Save(*cfg); err != nil {
+		return err
+	}
+	loaded, err := config.Load()
+	if err != nil {
+		return err
+	}
+	c := newCache(loaded)
+	_ = c.Load()
+	if err := hook.WriteAliasFiles(hook.BuildAliasEntries(c.All(), *loaded)); err != nil {
+		fmt.Fprintf(os.Stderr, "warning: could not write alias files: %v\n", err)
+	}
+	return nil
+}

cmd/netssh/hosts_test.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+)
+
+// prepareConfig writes data as the only config, with empty cache and home.
+func prepareConfig(t *testing.T, data string) string {
+	t.Helper()
+	dir := t.TempDir()
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("XDG_CONFIG_HOME", dir)
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	t.Setenv("NETSSH_NETBOX_URL", "")
+	t.Setenv("NETSSH_NETBOX_TOKEN", "")
+	t.Setenv("NETSSH_CACHE_PATH", filepath.Join(t.TempDir(), "hosts.json"))
+	t.Setenv("NETSSH_SHELL_ALIAS", "")
+	path := filepath.Join(dir, "netssh.yaml")
+	if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+const staticOnlyConfig = `ssh:
+  default_user: ops
+  rules:
+    - match: {kind: static, tag: home}
+      host_key_checking: accept-new
+shortcuts:
+  domains: [.lan]
+hosts:
+  - name: router.lan
+    address: 192.168.1.1
+    user: admin
+    port: 2222
+    tags: [home]
+  - name: nas
+    address: nas.example.org
+    ssh:
+      proxy_jump: jh.example.com
+`
+
+// Static hosts work without any NetBox and with their own user, port, tags, and options.
+func TestStaticHostsWithoutNetBox(t *testing.T) {
+	prepareConfig(t, staticOnlyConfig)
+	for _, tc := range []struct {
+		args []string
+		want string
+	}{
+		{[]string{"--dry-run", "router.lan"}, "ssh -p 2222 -l admin -o StrictHostKeyChecking=accept-new 192.168.1.1"},
+		{[]string{"--dry-run", "router"}, "ssh -p 2222 -l admin -o StrictHostKeyChecking=accept-new 192.168.1.1"}, // shortcut
+		{[]string{"--dry-run", "-l", "root", "nas", "uptime"}, "ssh -l root -J jh.example.com nas.example.org uptime"},
+		{[]string{"sftp", "--dry-run", "router:/etc"}, "sftp -P 2222 -o User=admin -o StrictHostKeyChecking=accept-new 192.168.1.1:/etc"},
+		{[]string{"scp", "--dry-run", "a.txt", "nas:/tmp/"}, "scp -o User=ops -J jh.example.com a.txt nas.example.org:/tmp/"},
+	} {
+		out, err := runNetssh(t, tc.args...)
+		if err != nil || out != tc.want {
+			t.Errorf("%v:\n got  %s (%v)\n want %s", tc.args, out, err, tc.want)
+		}
+	}
+	if out, err := runNetssh(t, "--dry-run", "unknown"); err == nil || !strings.Contains(out, "no NetBox is configured") {
+		t.Errorf("unknown host: %s (%v)", out, err)
+	}
+	if out, _ := runNetssh(t, "__complete", "rou"); !strings.HasPrefix(out, "router.lan\n") {
+		t.Errorf("completion: %q", out)
+	}
+	if out, _ := runNetssh(t, "alias", "--shell", "bash"); !strings.Contains(out, "alias router='netssh router.lan'") || !strings.Contains(out, "alias nas='netssh nas'") {
+		t.Errorf("aliases: %s", out)
+	}
+}
+
+func TestHostsCommand(t *testing.T) {
+	path := prepareConfig(t, "hosts:\n  - {name: nas, address: nas.example.org, ssh: {proxy_jump: jh}}\n")
+	steps := []struct {
+		args    []string
+		wantErr string
+	}{
+		{[]string{"hosts", "add", "router", "192.168.1.1", "--user", "admin", "--port", "2222", "--tag", "home", "--tag", "lab"}, ""},
+		{[]string{"hosts", "add", "router", "10.0.0.1"}, "already exists"},
+		{[]string{"hosts", "add", "nas", "10.0.0.5", "--replace"}, ""},
+		{[]string{"hosts", "add", "bad name", "10.0.0.1"}, "must start with"},
+		{[]string{"hosts", "remove", "missing"}, "no static host"},
+	}
+	for _, step := range steps {
+		out, err := runNetssh(t, step.args...)
+		if step.wantErr == "" && err != nil || step.wantErr != "" && !strings.Contains(out, step.wantErr) {
+			t.Fatalf("%v: %s (%v)", step.args, out, err)
+		}
+	}
+	cfg, err := config.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	router, nas := cfg.StaticHost("router"), cfg.StaticHost("nas")
+	if router == nil || router.User != "admin" || router.Port != 2222 || strings.Join(router.Tags, ",") != "home,lab" {
+		t.Fatalf("router: %+v", router)
+	}
+	if nas == nil || nas.Address != "10.0.0.5" || nas.SSH.ProxyJump != "jh" {
+		t.Fatalf("--replace must keep SSH options: %+v", nas)
+	}
+	out, err := runNetssh(t, "hosts", "list")
+	if err != nil || !strings.Contains(out, "router  192.168.1.1  admin  2222  home,lab") {
+		t.Fatalf("list:\n%s (%v)", out, err)
+	}
+	if out, err := runNetssh(t, "hosts", "rm", "router"); err != nil {
+		t.Fatalf("remove: %s (%v)", out, err)
+	}
+	data, _ := os.ReadFile(path)
+	if strings.Contains(string(data), "router") || strings.Contains(string(data), "netbox:") {
+		t.Fatalf("config after remove:\n%s", data)
+	}
+}
+
+// The hostname strategy passes the NetBox name (plus domain) instead of an IP.
+func TestHostnameStrategyConnects(t *testing.T) {
+	srv := connectionTestServer(t, []connectionTestHost{{ID: 1, Name: "web01"}, multiHost("db01", "10.0.0.7")}, nil)
+	prepareConfig(t, fmt.Sprintf("netbox:\n  url: %q\n  token: t\nresolver:\n  strategies: [primary_ip, hostname]\n  hostname_domain: example.com\n", srv.URL))
+	for host, want := range map[string]string{"web01": "ssh web01.example.com", "db01": "ssh 10.0.0.7"} {
+		if out, err := runNetssh(t, "--dry-run", host); err != nil || out != want {
+			t.Errorf("%s: got %s (%v), want %s", host, out, err, want)
+		}
+	}
+}

cmd/netssh/instances.go

@@ -10,6 +10,11 @@ import (
 	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/shortcuts"
 )
 
+// newCache opens the host cache with the config's static hosts.
+func newCache(cfg *config.Config) *cache.Cache {
+	return cache.New(cfg.CachePath(), cfg.Cache.TTL).WithStatic(cfg.Hosts)
+}
+
 func newNetBoxClient(cfg *config.Config) *netbox.Client {
 	if len(cfg.NetBoxes) > 0 {
 		sources := make([]netbox.Source, 0, len(cfg.NetBoxes))

cmd/netssh/main.go

@@ -45,6 +45,9 @@ var managedSubcommands = map[string]bool{
 	"sftp":       true,
 	"scp":        true,
 	"tunnel":     true,
+	"hosts":      true,
+	"multi":      true,
+	"sync":       true,
 }
 
 func main() {
@@ -75,7 +78,7 @@ func loadConfigOrSetup() *config.Config {
 	if err != nil {
 		fatalf("config: %v", err)
 	}
-	if !cfg.HasNetBox() {
+	if !cfg.HasHosts() {
 		fmt.Fprintln(os.Stderr, "No configuration found. Starting setup…")
 		if err := setup.RunWizard(cfg); err != nil {
 			fatalf("setup: %v", err)
@@ -129,6 +132,7 @@ func findDestination(client internalssh.Client, args []string) (*destination, er
 // runClient resolves the NetBox host in args and execs ssh, sftp, or scp.
 func runClient(client internalssh.Client, flags internalssh.WrapperFlags, args []string) {
 	cfg := loadConfigOrSetup()
+	client = client.WithInstances(instanceNames(cfg))
 
 	dest, err := findDestination(client, args)
 	if err != nil {
@@ -143,16 +147,44 @@ func runClient(client internalssh.Client, flags internalssh.WrapperFlags, args [
 		return
 	}
 
-	// Inject the configured default user if none was given on the command line.
-	if cfg.SSH.DefaultUser != "" && dest.user == "" && !client.HasUserFlag(args) {
-		args = prependArgs(client.UserArgs(cfg.SSH.DefaultUser), args, dest.dests)
+	host := resolveTarget(cfg, dest.host)
+	user, port := hostDefaults(cfg, host)
+	// Inject the default user if none was given on the command line.
+	if user != "" && dest.user == "" && !client.HasUserFlag(args) {
+		args = prependArgs(client.UserArgs(user), args, dest.dests)
 	}
-	// Inject the configured default port if none was given on the command line.
-	if cfg.SSH.DefaultPort > 0 && !client.HasPortFlag(args) {
-		args = prependArgs(client.PortArgs(strconv.Itoa(cfg.SSH.DefaultPort)), args, dest.dests)
+	// Inject the default port if none was given on the command line.
+	if port > 0 && !client.HasPortFlag(args) {
+		args = prependArgs(client.PortArgs(strconv.Itoa(port)), args, dest.dests)
 	}
 
-	connectHost(cfg, client, flags, resolveTarget(cfg, dest.host), dest.dests, args)
+	connectHost(cfg, client, flags, host, dest.dests, args)
+}
+
+// hostDefaults returns the login user and port for host: those of a static
+// host if set, else ssh.default_user and ssh.default_port.
+func hostDefaults(cfg *config.Config, host resolvedHost) (string, int) {
+	user, port := cfg.SSH.DefaultUser, cfg.SSH.DefaultPort
+	if host.Kind == config.StaticKind {
+		if static := cfg.StaticHost(host.Name); static != nil {
+			if static.User != "" {
+				user = static.User
+			}
+			if static.Port > 0 {
+				port = static.Port
+			}
+		}
+	}
+	return user, port
+}
+
+// instanceNames lists the named NetBox instances, which may prefix hostnames.
+func instanceNames(cfg *config.Config) []string {
+	names := make([]string, 0, len(cfg.NetBoxes))
+	for _, source := range cfg.NetBoxes {
+		names = append(names, source.Name)
+	}
+	return names
 }
 
 // prependArgs puts extra before args and shifts the destination indices.
@@ -174,7 +206,7 @@ type resolvedHost struct {
 // resolveTarget finds host in the cache (also by shortcut) or NetBox and
 // resolves its address. It exits on failure.
 func resolveTarget(cfg *config.Config, host string) resolvedHost {
-	c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+	c := newCache(cfg)
 	_ = c.Load()
 	maybeBackgroundRefresh(cfg, c)
 
@@ -186,6 +218,21 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost {
 		return resolvedHost{Name: entry.Name, Kind: entry.Kind, IP: entry.IP, Tags: entry.Tags}
 	}
 
+	// Static hosts from the config win and need no NetBox.
+	if source == "" {
+		var normalize func(string) string
+		if cfg.Shortcuts.Enabled() {
+			normalize = normalizeTarget(cfg.Shortcuts, false)
+		}
+		entry, found, err := c.GetStatic(host, normalize)
+		if err != nil {
+			fatalf("%v", err)
+		}
+		if found {
+			return used(entry)
+		}
+	}
+
 	// Cache hit with a fresh TTL — connect directly without querying NetBox.
 	if entry, fresh := c.Get(host); fresh && useCache {
 		return used(entry)
@@ -211,7 +258,7 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost {
 	}
 
 	if !cfg.HasNetBox() {
-		fatalf("netbox.url is not configured (~/.config/netssh.yaml)")
+		fatalf("host %q is not in hosts: and no NetBox is configured (netssh configure)", host)
 	}
 	nbClient := newNetBoxClient(cfg)
 
@@ -246,7 +293,7 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost {
 		fatalf("IP resolution for %q: %v", host, err)
 	}
 
-	entry := cache.Entry{Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags}
+	entry := cache.Entry{Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster}
 	c.Upsert(entry)
 	return used(entry)
 }
@@ -316,7 +363,7 @@ func execClient(client internalssh.Client, result internalssh.Result, flags inte
 func runTUI() {
 	cfg := loadConfigOrSetup()
 
-	c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+	c := newCache(cfg)
 	_ = c.Load()
 	maybeBackgroundRefresh(cfg, c)
 
@@ -344,6 +391,12 @@ func runTUI() {
 	if host == nil {
 		return
 	}
+	if host.Action == tui.ActionMulti {
+		if err := runMulti(cfg, host.Targets, multiFlags{}); err != nil {
+			fatalf("%v", err)
+		}
+		return
+	}
 
 	// Revalidate stale or live TUI results through the configured resolver chain.
 	var tags []string
@@ -368,7 +421,7 @@ func runTUI() {
 		if err != nil {
 			fatalf("IP resolution: %v", err)
 		}
-		c.Upsert(cache.Entry{Name: target.Target(), IP: host.IP, Kind: target.Kind, Tags: target.Tags})
+		c.Upsert(cache.Entry{Name: target.Target(), IP: host.IP, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster})
 		tags = target.Tags
 	}
 	fmt.Fprintf(os.Stderr, "Connecting to %s (%s)…\n", host.Name, host.IP)
@@ -392,17 +445,18 @@ func tuiCommand(cfg *config.Config, host *tui.SelectedHost) (internalssh.Client,
 	}
 
 	var args []string
-	// User override from TUI edit mode takes priority, then config default.
+	// User override from TUI edit mode takes priority, then static host and config defaults.
+	defaultUser, defaultPort := hostDefaults(cfg, resolvedHost{Name: host.Name, Kind: host.Kind})
 	user := host.User
 	if user == "" {
-		user = cfg.SSH.DefaultUser
+		user = defaultUser
 	}
 	if user != "" {
 		args = append(args, client.UserArgs(user)...)
 	}
 	port := host.Port
-	if port == "" && cfg.SSH.DefaultPort > 0 {
-		port = strconv.Itoa(cfg.SSH.DefaultPort)
+	if port == "" && defaultPort > 0 {
+		port = strconv.Itoa(defaultPort)
 	}
 	if port != "" {
 		args = append(args, client.PortArgs(port)...)
@@ -453,7 +507,7 @@ func rootCmd() *cobra.Command {
 		},
 	}
 
-	root.AddCommand(notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd(), sftpCmd(), scpCmd(), tunnelCmd())
+	root.AddCommand(notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd(), sftpCmd(), scpCmd(), tunnelCmd(), hostsCmd(), multiCmd(), syncCmd())
 
 	// cobra builds the "completion" command lazily; force init so we can extend it.
 	root.InitDefaultCompletionCmd()
@@ -575,7 +629,7 @@ func searchCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			if err := c.Load(); err != nil {
 				return err
 			}
@@ -609,7 +663,7 @@ func cacheListCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			if err := c.Load(); err != nil {
 				return err
 			}
@@ -635,7 +689,7 @@ func cacheClearCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			c.Clear()
 			if err := c.Save(); err != nil {
 				return err
@@ -677,7 +731,7 @@ func cacheRefreshCmd() *cobra.Command {
 				return fmt.Errorf("NetBox: %w", err)
 			}
 
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			_ = c.Load()
 
 			chain, err := resolver.New(cfg.Resolver)
@@ -708,7 +762,7 @@ func cacheRefreshCmd() *cobra.Command {
 					fmt.Fprintf(os.Stderr, "warning: skipping %s: %v\n", e.Name, err)
 					continue
 				}
-				c.Upsert(cache.Entry{Name: e.Target(), IP: ip, Kind: e.Kind, Tags: e.Tags})
+				c.Upsert(cache.Entry{Name: e.Target(), IP: ip, Kind: e.Kind, Tags: e.Tags, Cluster: e.Cluster})
 				written++
 			}
 
@@ -762,7 +816,7 @@ Or use in a script:
 			if err != nil {
 				return err
 			}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			if err := c.Load(); err != nil {
 				return err
 			}
@@ -838,7 +892,7 @@ func shellInitCmd() *cobra.Command {
 			if err != nil {
 				return nil
 			}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			_ = c.Load()
 
 			// Regenerate alias files from the current cache every shell start
@@ -897,7 +951,7 @@ After installation, reload your profile or open a new shell.`,
 			// Generate the aliases file immediately so it is ready on the next shell start.
 			cfg, cfgErr := config.Load()
 			if cfgErr == nil && cfg.HasNetBox() {
-				c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+				c := newCache(cfg)
 				if _ = c.Load(); true {
 					if entries := buildAliasEntries(c, *cfg); len(entries) > 0 {
 						if err := hook.WriteAliasFiles(entries); err != nil {
@@ -949,7 +1003,8 @@ func hookUninstallCmd() *cobra.Command {
 // maybeBackgroundRefresh starts a background `netssh cache refresh` if the cache
 // has not been fully refreshed within the last 24 hours.
 func maybeBackgroundRefresh(cfg *config.Config, c *cache.Cache) {
-	if !cfg.HasNetBox() {
+	// netssh multi checks once and starts its panes with NETSSH_NO_REFRESH.
+	if !cfg.HasNetBox() || os.Getenv("NETSSH_NO_REFRESH") != "" {
 		return
 	}
 	if !c.NeedsRefresh(24 * time.Hour) {

cmd/netssh/multi.go

@@ -0,0 +1,414 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/multiplex"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
+)
+
+// maxHostsWithoutConfirm guards against opening hundreds of panes by accident.
+const maxHostsWithoutConfirm = 24
+
+// multiFlags are the options shared by netssh multi and the TUI.
+type multiFlags struct {
+	kind, user, jump, multiplexer string
+	noJump, sync, dryRun, yes     bool
+}
+
+func multiCmd() *cobra.Command {
+	var f multiFlags
+	var useTmux, useZellij bool
+	cmd := &cobra.Command{
+		Use:   "multi [flags] HOST|tag:TAG|cluster:NAME|@GROUP...",
+		Short: "Open several hosts side by side in tmux or zellij",
+		Long: `Open one pane per host in a tmux window or zellij tab. Hosts are given as
+names (shortcuts, instance/host, static hosts) or selectors:
+
+  tag:TAG        all hosts with this NetBox tag, and static hosts with this tag
+  cluster:NAME   devices of a NetBox virtualization cluster (--kind vm|all for VMs)
+  @GROUP         a group from the config (groups:)
+
+Broadcast typing to all panes of a window with --sync, or toggle it later with
+netssh sync. Inside tmux or zellij the panes open in the current session.`,
+		Example: `  netssh multi web01 web02 db01
+  netssh multi cluster:pve-fsn1
+  netssh multi --kind vm cluster:pve-fsn1
+  netssh multi --sync tag:k8s-worker
+  netssh multi @k8s`,
+		Args: cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if useTmux && useZellij {
+				return errors.New("--tmux and --zellij are mutually exclusive")
+			}
+			if useTmux {
+				f.multiplexer = multiplex.Tmux
+			} else if useZellij {
+				f.multiplexer = multiplex.Zellij
+			}
+			return runMulti(loadConfigOrSetup(), args, f)
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+			cfg, err := config.Load()
+			if err != nil {
+				return nil, cobra.ShellCompDirectiveError
+			}
+			return multiCompletions(cfg, toComplete)
+		},
+	}
+	cmd.Flags().StringVar(&f.kind, "kind", "", "Host kind for tag: and cluster: — device, vm, or all (default: all for tags, device for clusters)")
+	cmd.Flags().BoolVar(&f.sync, "sync", false, "Start with typing broadcast to all panes")
+	cmd.Flags().BoolVar(&useTmux, "tmux", false, "Use tmux")
+	cmd.Flags().BoolVar(&useZellij, "zellij", false, "Use zellij")
+	cmd.Flags().StringVarP(&f.user, "user", "l", "", "Login user for every host")
+	cmd.Flags().StringVar(&f.jump, "jump", "", "Jump host for every host")
+	cmd.Flags().BoolVar(&f.noJump, "no-jump", false, "Disable jump hosts")
+	cmd.Flags().BoolVar(&f.dryRun, "dry-run", false, "Print the hosts and multiplexer commands")
+	cmd.Flags().BoolVarP(&f.yes, "yes", "y", false, fmt.Sprintf("Open more than %d hosts without asking", maxHostsWithoutConfirm))
+	_ = cmd.RegisterFlagCompletionFunc("kind", cobra.FixedCompletions([]cobra.Completion{"device", "vm", "all"}, cobra.ShellCompDirectiveNoFileComp))
+	return cmd
+}
+
+func syncCmd() *cobra.Command {
+	var pane bool
+	cmd := &cobra.Command{
+		Use:   "sync [--pane]",
+		Short: "Toggle typing into all panes of the current tmux window or zellij tab",
+		Long: `Toggle broadcast in the current tmux window or zellij tab. With --pane,
+exclude the current tmux pane from broadcast, or include it again.
+
+In windows opened by netssh multi, tmux also has keys for this:
+prefix S (all panes) and prefix e (this pane); see multi.sync_key and
+multi.solo_key. In zellij, use Ctrl+t then s.`,
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			state, err := multiplex.ToggleSync(multiplex.System{}, pane)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintln(os.Stderr, "netssh: "+state)
+			return nil
+		},
+	}
+	cmd.Flags().BoolVar(&pane, "pane", false, "Exclude the current tmux pane from broadcast, or include it again")
+	return cmd
+}
+
+// runMulti expands selectors and opens one pane per host.
+func runMulti(cfg *config.Config, selectors []string, f multiFlags) error {
+	if f.jump != "" && f.noJump {
+		return errors.New("--jump and --no-jump are mutually exclusive")
+	}
+	switch f.kind {
+	case "", "device", "vm", "all":
+	default:
+		return fmt.Errorf("--kind must be device, vm, or all")
+	}
+	c := newCache(cfg)
+	_ = c.Load()
+	targets, warnings, err := expandSelectors(cfg, c, selectors, f.kind)
+	for _, warning := range warnings {
+		fmt.Fprintln(os.Stderr, "netssh: warning: "+warning)
+	}
+	if err != nil {
+		return err
+	}
+	if len(targets) > maxHostsWithoutConfirm && !f.yes && !f.dryRun {
+		return fmt.Errorf("%d hosts selected; pass --yes to open them all", len(targets))
+	}
+
+	var runner multiplex.Runner = multiplex.System{}
+	if f.dryRun {
+		fmt.Printf("# %d hosts: %s\n", len(targets), strings.Join(targets, " "))
+		runner = &multiplex.DryRun{W: os.Stdout}
+	}
+	requested := f.multiplexer
+	if requested == "" {
+		requested = cfg.Multi.Multiplexer
+	}
+	kind, err := multiplex.Detect(requested, runner)
+	if err != nil {
+		return err
+	}
+	if !f.dryRun {
+		// Checked once here; the panes skip it (NETSSH_NO_REFRESH).
+		maybeBackgroundRefresh(cfg, c)
+	}
+
+	panes := make([]multiplex.Pane, 0, len(targets))
+	for _, target := range targets {
+		panes = append(panes, multiplex.Pane{Title: target, Argv: paneArgv(target, f)})
+	}
+	layoutDir := filepath.Dir(cfg.Cache.Path)
+	if err := os.MkdirAll(layoutDir, 0o700); err != nil {
+		return err
+	}
+	syncKey, soloKey := cfg.Multi.Keys()
+	return multiplex.Open(kind, panes, multiplex.Options{
+		SyncKey:   syncKey,
+		SoloKey:   soloKey,
+		Label:     multiLabel(selectors),
+		Sync:      f.sync,
+		PerWindow: cfg.Multi.PanesPerWindowOrDefault(),
+		LayoutDir: layoutDir,
+		Hint:      func(s string) { fmt.Fprintln(os.Stderr, "netssh: "+s) },
+	}, runner)
+}
+
+// paneArgv runs netssh for one host. Panes of an existing tmux or zellij
+// session inherit that server's environment, so the paths that select the
+// config and cache are passed explicitly; NETSSH_* values are not, because
+// arguments are visible to other users (tokens).
+func paneArgv(target string, f multiFlags) []string {
+	self, err := os.Executable()
+	if err != nil {
+		self = "netssh"
+	}
+	env, err := exec.LookPath("env")
+	if err != nil {
+		env = "/usr/bin/env"
+	}
+	argv := []string{env, "NETSSH_NO_REFRESH=1"}
+	for _, key := range []string{"HOME", "XDG_CONFIG_HOME", "XDG_CACHE_HOME"} {
+		if value, ok := os.LookupEnv(key); ok {
+			argv = append(argv, key+"="+value)
+		}
+	}
+	argv = append(argv, self)
+	switch {
+	case f.jump != "":
+		argv = append(argv, "--jump", f.jump)
+	case f.noJump:
+		argv = append(argv, "--no-jump")
+	}
+	if f.user != "" {
+		argv = append(argv, "-l", f.user)
+	}
+	return append(argv, target)
+}
+
+var unsafeLabel = regexp.MustCompile(`[^A-Za-z0-9_-]+`)
+
+// multiLabel names the window, session, or tab after a single selector.
+func multiLabel(selectors []string) string {
+	if len(selectors) != 1 {
+		return "multi"
+	}
+	s := selectors[0]
+	for _, prefix := range []string{"@", "tag:", "cluster:"} {
+		s = strings.TrimPrefix(s, prefix)
+	}
+	if s = strings.Trim(unsafeLabel.ReplaceAllString(s, "-"), "-"); s == "" {
+		return "multi"
+	}
+	return s
+}
+
+// expander resolves selectors into an ordered list of unique host targets.
+type expander struct {
+	cfg      *config.Config
+	cache    *cache.Cache
+	kind     string
+	client   *netbox.Client
+	seen     map[string]bool
+	visiting map[string]bool
+	targets  []string
+	warnings []string
+}
+
+func expandSelectors(cfg *config.Config, c *cache.Cache, selectors []string, kind string) ([]string, []string, error) {
+	e := &expander{cfg: cfg, cache: c, kind: kind, seen: map[string]bool{}, visiting: map[string]bool{}}
+	for _, selector := range selectors {
+		if err := e.expand(selector); err != nil {
+			return nil, e.warnings, err
+		}
+	}
+	if len(e.targets) == 0 {
+		return nil, e.warnings, errors.New("no hosts selected")
+	}
+	return e.targets, e.warnings, nil
+}
+
+func (e *expander) add(target string) {
+	key := strings.ToLower(target)
+	if !e.seen[key] {
+		e.seen[key] = true
+		e.targets = append(e.targets, target)
+	}
+}
+
+func (e *expander) expand(selector string) error {
+	switch {
+	case strings.HasPrefix(selector, "@"):
+		return e.group(strings.ToLower(strings.TrimPrefix(selector, "@")))
+	case strings.HasPrefix(selector, "tag:"):
+		return e.query(selector, netbox.SearchOptions{Tag: strings.TrimPrefix(selector, "tag:")}, "all")
+	case strings.HasPrefix(selector, "cluster:"):
+		return e.query(selector, netbox.SearchOptions{Cluster: strings.TrimPrefix(selector, "cluster:")}, "device")
+	case selector == "":
+		return nil
+	}
+	e.add(selector)
+	return nil
+}
+
+func (e *expander) group(name string) error {
+	members, ok := e.cfg.Groups[name]
+	if !ok {
+		names := make([]string, 0, len(e.cfg.Groups))
+		for group := range e.cfg.Groups {
+			names = append(names, "@"+group)
+		}
+		sort.Strings(names)
+		if len(names) == 0 {
+			return fmt.Errorf("unknown group @%s; no groups are configured (groups:)", name)
+		}
+		return fmt.Errorf("unknown group @%s; available: %s", name, strings.Join(names, ", "))
+	}
+	if e.visiting[name] {
+		return fmt.Errorf("group @%s contains itself", name)
+	}
+	e.visiting[name] = true
+	defer delete(e.visiting, name)
+	for _, member := range members {
+		if err := e.expand(member); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// query expands tag: and cluster: through NetBox, plus static hosts for tags;
+// if NetBox fails, the cache answers with a warning.
+func (e *expander) query(selector string, opts netbox.SearchOptions, defaultKind string) error {
+	kind := e.kind
+	if kind == "" {
+		kind = defaultKind
+	}
+	if kind != "all" {
+		opts.Kind = kind
+	}
+	before := len(e.targets)
+	if opts.Tag != "" && (kind == "all" || kind == config.StaticKind) {
+		for _, host := range e.cfg.Hosts {
+			if hasTag(host.Tags, opts.Tag) {
+				e.add(host.Name)
+			}
+		}
+	}
+	if e.cfg.HasNetBox() {
+		if e.client == nil {
+			e.client = newNetBoxClient(e.cfg)
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		entries, err := e.client.SearchAll(ctx, "", opts)
+		cancel()
+		if err != nil {
+			e.warnings = append(e.warnings, fmt.Sprintf("%s: NetBox unavailable, using the cache: %v", selector, err))
+			entries = e.fromCache(opts)
+		} else {
+			sort.Slice(entries, func(i, j int) bool { return entries[i].Target() < entries[j].Target() })
+		}
+		for _, entry := range entries {
+			e.add(entry.Target())
+		}
+	}
+	if len(e.targets) == before {
+		hint := ""
+		if opts.Cluster != "" && e.kind == "" {
+			hint = " (only devices by default; try --kind vm or --kind all)"
+		}
+		return fmt.Errorf("%s matches no hosts%s", selector, hint)
+	}
+	return nil
+}
+
+func (e *expander) fromCache(opts netbox.SearchOptions) []netbox.HostEntry {
+	var out []netbox.HostEntry
+	for _, entry := range e.cache.All() {
+		if entry.Static || opts.Kind != "" && entry.Kind != opts.Kind {
+			continue
+		}
+		if opts.Tag != "" && !hasTag(entry.Tags, opts.Tag) || opts.Cluster != "" && !strings.EqualFold(entry.Cluster, opts.Cluster) {
+			continue
+		}
+		source, name := netbox.SplitTarget(entry.Name)
+		out = append(out, netbox.HostEntry{Source: source, Name: name, Kind: entry.Kind})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Target() < out[j].Target() })
+	return out
+}
+
+// hasTag compares a tag by name or slug, like ssh.rules.
+func hasTag(tags []string, want string) bool {
+	for _, tag := range tags {
+		if strings.EqualFold(tag, want) || strings.EqualFold(strings.Join(strings.Fields(strings.ToLower(tag)), "-"), want) {
+			return true
+		}
+	}
+	return false
+}
+
+// multiCompletions offers hosts, @groups, and tag:/cluster: values from the cache.
+func multiCompletions(cfg *config.Config, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+	c := newCache(cfg)
+	_ = c.Load()
+	lower := strings.ToLower(toComplete)
+	var out []string
+	switch {
+	case strings.HasPrefix(lower, "tag:"), strings.HasPrefix(lower, "cluster:"):
+		prefix, value, _ := strings.Cut(lower, ":")
+		values := map[string]bool{}
+		for _, entry := range c.All() {
+			if prefix == "tag" {
+				for _, tag := range entry.Tags {
+					values[strings.ToLower(tag)] = true
+				}
+			} else if entry.Cluster != "" {
+				values[entry.Cluster] = true
+			}
+		}
+		for v := range values {
+			if strings.HasPrefix(strings.ToLower(v), value) {
+				out = append(out, prefix+":"+v)
+			}
+		}
+	case strings.HasPrefix(lower, "@"):
+		for group := range cfg.Groups {
+			if strings.HasPrefix("@"+group, lower) {
+				out = append(out, "@"+group)
+			}
+		}
+	default:
+		out = completeHosts(toComplete)
+		var prefixes []string
+		for _, p := range []string{"tag:", "cluster:"} {
+			if toComplete != "" && strings.HasPrefix(p, lower) {
+				prefixes = append(prefixes, p)
+			}
+		}
+		if len(out) == 0 && len(prefixes) > 0 {
+			return prefixes, cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
+		}
+		for group := range cfg.Groups {
+			if toComplete == "" {
+				out = append(out, "@"+group)
+			}
+		}
+	}
+	sort.Strings(out)
+	return out, cobra.ShellCompDirectiveNoFileComp
+}

cmd/netssh/multi_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+)
+
+func TestExpandSelectors(t *testing.T) {
+	cfg := &config.Config{
+		Hosts: []config.StaticHost{{Name: "box", Address: "10.0.0.1", Tags: []string{"Web Servers"}}},
+		Groups: map[string][]string{
+			"all":  {"@web", "db1", "box"},
+			"web":  {"web1", "tag:web-servers", "web1"},
+			"loop": {"@loop"},
+		},
+	}
+	c := cache.New(t.TempDir()+"/hosts.json", 60).WithStatic(cfg.Hosts)
+	got, _, err := expandSelectors(cfg, c, []string{"@all", "WEB1"}, "")
+	if err != nil || !reflect.DeepEqual(got, []string{"web1", "box", "db1"}) {
+		t.Fatalf("got %v %v", got, err)
+	}
+	if _, _, err := expandSelectors(cfg, c, []string{"@loop"}, ""); err == nil || !strings.Contains(err.Error(), "contains itself") {
+		t.Fatalf("cycle: %v", err)
+	}
+	if _, _, err := expandSelectors(cfg, c, []string{"@nope"}, ""); err == nil || !strings.Contains(err.Error(), "available: @all, @loop, @web") {
+		t.Fatalf("unknown group: %v", err)
+	}
+	if _, _, err := expandSelectors(cfg, c, []string{"tag:web-servers"}, "device"); err == nil {
+		t.Fatal("--kind device must exclude static hosts")
+	}
+}
+
+// Without a reachable NetBox, tag: and cluster: fall back to the cache.
+func TestExpandSelectorsCacheFallback(t *testing.T) {
+	cfg := &config.Config{NetBox: config.NetBoxConfig{URL: "http://127.0.0.1:1", Token: "t", TokenVersion: 1}}
+	c := cache.New(t.TempDir()+"/hosts.json", 60)
+	c.Upsert(cache.Entry{Name: "node2", Kind: "device", Cluster: "pve"})
+	c.Upsert(cache.Entry{Name: "node1", Kind: "device", Cluster: "pve", Tags: []string{"pve"}})
+	c.Upsert(cache.Entry{Name: "vm1", Kind: "vm", Cluster: "pve"})
+	got, warnings, err := expandSelectors(cfg, c, []string{"cluster:PVE"}, "")
+	if err != nil || !reflect.DeepEqual(got, []string{"node1", "node2"}) || len(warnings) != 1 {
+		t.Fatalf("devices: %v %v %v", got, warnings, err)
+	}
+	if got, _, _ := expandSelectors(cfg, c, []string{"cluster:pve"}, "all"); len(got) != 3 {
+		t.Fatalf("all: %v", got)
+	}
+	if _, _, err := expandSelectors(cfg, c, []string{"cluster:other"}, ""); err == nil || !strings.Contains(err.Error(), "--kind vm") {
+		t.Fatalf("empty cluster: %v", err)
+	}
+}
+
+func TestMultiLabelAndPaneArgv(t *testing.T) {
+	for selectors, want := range map[string]string{"@k8s": "k8s", "cluster:pve-fsn1": "pve-fsn1", "tag:a.b": "a-b", "a b": "multi"} {
+		if got := multiLabel(strings.Fields(selectors)); got != want {
+			t.Errorf("%q: got %q", selectors, got)
+		}
+	}
+	t.Setenv("XDG_CONFIG_HOME", "/cfg")
+	t.Setenv("NETSSH_NETBOX_TOKEN", "secret")
+	argv := strings.Join(paneArgv("prod/web1", multiFlags{user: "ops", jump: "jh"}), " ")
+	for _, want := range []string{"NETSSH_NO_REFRESH=1", "XDG_CONFIG_HOME=/cfg", "--jump jh -l ops prod/web1"} {
+		if !strings.Contains(argv, want) {
+			t.Errorf("argv lacks %q: %s", want, argv)
+		}
+	}
+	if strings.Contains(argv, "secret") {
+		t.Fatalf("token leaked into the pane arguments: %s", argv)
+	}
+}
+
+func TestMultiDryRun(t *testing.T) {
+	prepareConfig(t, "hosts:\n  - {name: a, address: 10.0.0.1, tags: [web]}\n  - {name: b, address: 10.0.0.2, tags: [web]}\ngroups:\n  web: [\"tag:web\"]\n")
+	out, err := runNetssh(t, "multi", "--dry-run", "--tmux", "--sync", "@web")
+	if err != nil {
+		t.Fatalf("%s %v", out, err)
+	}
+	for _, want := range []string{"# 2 hosts: a b", "tmux new-session -d -x 240 -y 70 -s netssh-web", "synchronize-panes on", "tmux attach-session -t netssh-web"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("missing %q:\n%s", want, out)
+		}
+	}
+	if out, err := runNetssh(t, "multi", "--dry-run", "--zellij", "a", "b"); err != nil || !strings.Contains(out, `pane name="b"`) {
+		t.Errorf("zellij: %s %v", out, err)
+	}
+	if out, err := runNetssh(t, "sync"); err == nil || !strings.Contains(out, "inside tmux or zellij") {
+		t.Errorf("sync outside: %s %v", out, err)
+	}
+}

cmd/netssh/notes.go

@@ -38,7 +38,7 @@ func notesCmd() *cobra.Command {
 				client = newNetBoxClient(cfg)
 			}
 			host := netbox.HostEntry{Name: args[0], Kind: kind}
-			c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+			c := newCache(cfg)
 			if err := c.Load(); err != nil {
 				return err
 			}

cmd/netssh/transfer.go

@@ -133,7 +133,7 @@ func completeHosts(toComplete string) []string {
 	if err != nil {
 		return nil
 	}
-	c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+	c := newCache(cfg)
 	_ = c.Load()
 	hosts := hostCompletions(c.All(), toComplete, cfg.Shortcuts)
 	if limit := cfg.Completion.MaxResults; limit > 0 && len(hosts) > limit {
@@ -144,7 +144,7 @@ func completeHosts(toComplete string) []string {
 
 // cachedHost finds a host for completion by name or shortcut, without NetBox.
 func cachedHost(cfg *config.Config, host string) (cache.Entry, bool) {
-	c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
+	c := newCache(cfg)
 	if err := c.Load(); err != nil {
 		return cache.Entry{}, false
 	}

go.mod

@@ -1,15 +1,15 @@
 module git.zb-server.de/Sebi/ssh-netbox-wrapper
 
-go 1.27.3
+go 1.27.4
 
 require (
 	charm.land/bubbles/v2 v2.2.1
-	charm.land/bubbletea/v2 v2.1.0
+	charm.land/bubbletea/v2 v2.1.1
 	charm.land/huh/v2 v2.0.3
-	charm.land/lipgloss/v2 v2.0.6
+	charm.land/lipgloss/v2 v2.1.0
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/viper v1.21.0
-	golang.org/x/sys v0.49.0
+	golang.org/x/sys v0.50.0
 )
 
 require (
@@ -43,11 +43,11 @@ require (
 	github.com/sahilm/fuzzy v0.1.3 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/cast v1.10.0 // indirect
-	github.com/spf13/pflag v1.0.10 // indirect
+	github.com/spf13/pflag v1.1.0 // indirect
 	github.com/stretchr/testify v1.12.1 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/xo/terminfo v1.2.0 // indirect
-	go.yaml.in/yaml/v3 v3.0.5 // indirect
-	golang.org/x/sync v0.24.0 // indirect
-	golang.org/x/text v0.43.0 // indirect
+	github.com/xo/terminfo v1.3.1 // indirect
+	go.yaml.in/yaml/v3 v3.0.6 // indirect
+	golang.org/x/sync v0.25.0 // indirect
+	golang.org/x/text v0.44.0 // indirect
 )

go.sum

@@ -1,11 +1,11 @@
 charm.land/bubbles/v2 v2.2.1 h1:Fq1+qm5hV6GkvzLQDhCBpXXE5tLgvh1PRriCLwSvIQU=
 charm.land/bubbles/v2 v2.2.1/go.mod h1:wdMgn+sje1KNXdwFizIWjbf328fIUBxqEmJ/vYPo8yc=
-charm.land/bubbletea/v2 v2.1.0 h1:A9fj9h5LFrvQhQHFNggp8K8rvY6CUfgn9dMbb6p2HIw=
-charm.land/bubbletea/v2 v2.1.0/go.mod h1:xWHeyxIX9/wiFU2kgPW04ojOZyTzrWf+8lGjUCaftiU=
+charm.land/bubbletea/v2 v2.1.1 h1:S1S9l37pCZGrj1JexBcr9x4Nr3MVeM42InqCYM/tDpU=
+charm.land/bubbletea/v2 v2.1.1/go.mod h1:xWHeyxIX9/wiFU2kgPW04ojOZyTzrWf+8lGjUCaftiU=
 charm.land/huh/v2 v2.0.3 h1:2cJsMqEPwSywGHvdlKsJyQKPtSJLVnFKyFbsYZTlLkU=
 charm.land/huh/v2 v2.0.3/go.mod h1:93eEveeeqn47MwiC3tf+2atZ2l7Is88rAtmZNZ8x9Wc=
-charm.land/lipgloss/v2 v2.0.6 h1:EaGKeuA8FvF+v2BT5VmZd2LoYLaMZJXA5n34th8nCIQ=
-charm.land/lipgloss/v2 v2.0.6/go.mod h1:ipDDJNSGa1hlwDtSfW1s2/xR8Vdhbut4PXh2zEKZd0Q=
+charm.land/lipgloss/v2 v2.1.0 h1:RLCNLhSQST+NPOmvUSbRWZ3UFOXsf3ZXFmJ5E/2tHEU=
+charm.land/lipgloss/v2 v2.1.0/go.mod h1:wwfOgrNqUA9yjL8nmG6BIO0qQnmkEgJ8ISptbme83gI=
 github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
 github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
@@ -87,23 +87,23 @@ github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qq
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.1.0 h1:6W6MbVUrnMb8PEhjkqwsVLY7ryuzRfFHF4mQd7L94ag=
+github.com/spf13/pflag v1.1.0/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
 github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
 github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
 github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/xo/terminfo v1.2.0 h1:d0ZTOCpuGE0lwSAOs0zcJjwz3jWQyqcRt9XbGJpCOl4=
-github.com/xo/terminfo v1.2.0/go.mod h1:lGzkSo8Fe7IRh/w+Gqz7n5mDog4FVXCj3gy/DYTBqio=
+github.com/xo/terminfo v1.3.1 h1:4ZwPCuu4PEFw0PkNp3Hv/x3gqvgLCzYhurszsj101cM=
+github.com/xo/terminfo v1.3.1/go.mod h1:lGzkSo8Fe7IRh/w+Gqz7n5mDog4FVXCj3gy/DYTBqio=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
-go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
-golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
-golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
-golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
-golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
-golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
-golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
+go.yaml.in/yaml/v3 v3.0.6 h1:zcDfvjXEqTQmpjniUBLc91xYJMB2c4QOFxEF/LCEckM=
+go.yaml.in/yaml/v3 v3.0.6/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
+golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs=
+golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
+golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs=
+golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo=
+golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/cache/cache.go

@@ -12,6 +12,7 @@ import (
 
 	"golang.org/x/sys/unix"
 
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
 	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
 )
 
@@ -20,8 +21,12 @@ type Entry struct {
 	IP       string    `json:"ip"`
 	Kind     string    `json:"kind"`
 	Tags     []string  `json:"tags,omitempty"`
+	Cluster  string    `json:"cluster,omitempty"`
 	CachedAt time.Time `json:"cached_at"`
 	LastUsed time.Time `json:"last_used,omitempty"`
+	// Static marks a host from the config's hosts: list. It never expires;
+	// it is stored only to remember LastUsed for the recently-used list.
+	Static bool `json:"static,omitempty"`
 }
 
 type changeKind uint8
@@ -40,6 +45,7 @@ type Cache struct {
 	path         string
 	ttl          time.Duration
 	refreshStamp string // path to last_refresh timestamp file
+	static       []config.StaticHost
 }
 
 type diskFormat struct {
@@ -98,6 +104,7 @@ func (c *Cache) Load() error {
 
 	data, err := os.ReadFile(c.path)
 	if os.IsNotExist(err) {
+		c.applyStatic()
 		return nil
 	}
 	if err != nil {
@@ -115,6 +122,7 @@ func (c *Cache) Load() error {
 	for _, e := range df.Entries {
 		c.entries[e.Name] = e
 	}
+	c.applyStatic()
 	return nil
 }
 
@@ -188,6 +196,15 @@ func (c *Cache) Save() error {
 	if err := storage.WriteFile(c.path, data, 0o600); err != nil {
 		return err
 	}
+	// Static hosts come from the config, not the file: keep them in memory.
+	for name, e := range c.entries {
+		if e.Static {
+			if old, ok := merged[name]; ok && old.LastUsed.After(e.LastUsed) {
+				e.LastUsed = old.LastUsed
+			}
+			merged[name] = e
+		}
+	}
 	c.entries = merged
 	c.dirty = make(map[string]changeKind)
 	c.cleared = false
@@ -221,7 +238,10 @@ func (c *Cache) MarkUsed(name string) {
 	if e, ok := c.entries[name]; ok {
 		e.LastUsed = time.Now()
 		c.entries[name] = e
-		if _, changed := c.dirty[name]; !changed {
+		if e.Static {
+			// A static host may not be on disk yet; usage alone would not add it.
+			c.dirty[name] = upsertChange
+		} else if _, changed := c.dirty[name]; !changed {
 			c.dirty[name] = usageChange
 		}
 	}
@@ -279,7 +299,7 @@ func (c *Cache) GetByShortcut(shortcut string, normalize func(string) string) (e
 			entry, found = e, true
 		}
 	}
-	return entry, found, found && c.ttl > 0 && time.Since(entry.CachedAt) < c.ttl, nil
+	return entry, found, found && (entry.Static || c.ttl > 0 && time.Since(entry.CachedAt) < c.ttl), nil
 }
 
 // Get returns an entry and reports whether it is still within the TTL.
@@ -291,20 +311,92 @@ func (c *Cache) Get(name string) (entry Entry, fresh bool) {
 	if !ok {
 		return Entry{}, false
 	}
+	if e.Static {
+		return e, true
+	}
 	if c.ttl == 0 {
 		return e, false
 	}
 	return e, time.Since(e.CachedAt) < c.ttl
 }
 
+// Clear removes all NetBox entries; static hosts come from the config and stay.
 func (c *Cache) Clear() {
 	c.mu.Lock()
-	c.entries = make(map[string]Entry)
+	static := make(map[string]Entry)
+	for name, e := range c.entries {
+		if e.Static {
+			static[name] = e
+		}
+	}
+	c.entries = static
 	c.dirty = make(map[string]changeKind)
 	c.cleared = true
 	c.mu.Unlock()
 }
 
+// SetStatic adds the config's static hosts. They replace cached entries of the
+// same name, keep their recorded LastUsed, and static entries that are no
+// longer configured are removed on the next Save.
+func (c *Cache) SetStatic(hosts []config.StaticHost) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.static = hosts
+	c.applyStatic()
+}
+
+// WithStatic sets the static hosts now and after every Load.
+func (c *Cache) WithStatic(hosts []config.StaticHost) *Cache {
+	c.SetStatic(hosts)
+	return c
+}
+
+func (c *Cache) applyStatic() {
+	hosts := c.static
+	configured := make(map[string]bool, len(hosts))
+	for _, host := range hosts {
+		e := Entry{Name: host.Name, IP: host.Address, Kind: config.StaticKind, Tags: host.Tags, CachedAt: time.Now(), Static: true}
+		if old, ok := c.entries[host.Name]; ok && old.Static {
+			e.LastUsed = old.LastUsed
+		}
+		c.entries[host.Name] = e
+		configured[host.Name] = true
+	}
+	for name, e := range c.entries {
+		if e.Static && !configured[name] {
+			delete(c.entries, name)
+			c.dirty[name] = deleteChange
+		}
+	}
+}
+
+// GetStatic finds a static host by name or by shortcut. Static hosts are
+// checked before NetBox, so they also work when NetBox is unreachable.
+func (c *Cache) GetStatic(name string, normalize func(string) string) (Entry, bool, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	var match Entry
+	found := false
+	for key, e := range c.entries {
+		if e.Static && strings.EqualFold(key, name) {
+			return e, true, nil
+		}
+	}
+	if normalize == nil {
+		return Entry{}, false, nil
+	}
+	short := normalize(name)
+	for _, e := range c.entries {
+		if e.Static && normalize(e.Name) == short {
+			if found {
+				return Entry{}, false, fmt.Errorf("ambiguous shortcut %q; use a full hostname", name)
+			}
+			match, found = e, true
+		}
+	}
+	return match, found, nil
+}
+
 func (c *Cache) All() []Entry {
 	c.mu.RLock()
 	defer c.mu.RUnlock()

internal/cache/cache_test.go

@@ -4,8 +4,11 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
 )
 
 func TestNew(t *testing.T) {
@@ -495,3 +498,62 @@ func TestSearchMatchesHostnamesAcrossQualifiedSources(t *testing.T) {
 		}
 	}
 }
+
+func TestStaticHosts(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "hosts.json")
+	hosts := []config.StaticHost{{Name: "router", Address: "192.168.1.1", Tags: []string{"home"}}, {Name: "nas", Address: "nas.lan"}}
+	c := New(path, 1).WithStatic(hosts)
+	c.Upsert(Entry{Name: "web01", IP: "10.0.0.1", Kind: "device"})
+	if err := c.Load(); err != nil { // no file yet; static hosts stay
+		t.Fatal(err)
+	}
+	if e, fresh := c.Get("router"); !fresh || e.IP != "192.168.1.1" || e.Kind != config.StaticKind || !e.Static {
+		t.Fatalf("static get: %+v %v", e, fresh)
+	}
+	if e, found, err := c.GetStatic("ROUTER", nil); !found || err != nil || e.Name != "router" {
+		t.Fatalf("by name: %+v %v %v", e, found, err)
+	}
+	normalize := func(s string) string { return strings.TrimSuffix(strings.ToLower(s), ".lan") }
+	if e, found, _ := c.GetStatic("nas.lan", normalize); !found || e.Name != "nas" {
+		t.Fatalf("by shortcut: %+v", e)
+	}
+	if _, found, _ := c.GetStatic("web01", normalize); found {
+		t.Fatal("NetBox entry returned as static")
+	}
+
+	// Usage of a static host persists; the host itself stays after Save and Clear.
+	c.MarkUsed("router")
+	if err := c.Save(); err != nil {
+		t.Fatal(err)
+	}
+	if _, fresh := c.Get("nas"); !fresh {
+		t.Fatal("static host lost after Save")
+	}
+	reloaded := New(path, 1).WithStatic(hosts)
+	if err := reloaded.Load(); err != nil {
+		t.Fatal(err)
+	}
+	if recent := reloaded.RecentlyUsed(5); len(recent) != 1 || recent[0].Name != "router" {
+		t.Fatalf("recent: %+v", recent)
+	}
+	reloaded.Clear()
+	if _, fresh := reloaded.Get("router"); !fresh {
+		t.Fatal("Clear removed a static host")
+	}
+
+	// A host removed from the config disappears, also from the file.
+	removed := New(path, 1).WithStatic(hosts[1:])
+	if err := removed.Load(); err != nil {
+		t.Fatal(err)
+	}
+	if e, _ := removed.Get("router"); e.Name != "" {
+		t.Fatalf("removed static host still present: %+v", e)
+	}
+	if err := removed.Save(); err != nil {
+		t.Fatal(err)
+	}
+	data, _ := os.ReadFile(path)
+	if strings.Contains(string(data), "192.168.1.1") {
+		t.Fatalf("removed static host still on disk:\n%s", data)
+	}
+}

internal/config/config.go

@@ -19,6 +19,10 @@ type Config struct {
 	SSH        SSHConfig        `mapstructure:"ssh"`
 	Shortcuts  ShortcutsConfig  `mapstructure:"shortcuts"`
 	Completion CompletionConfig `mapstructure:"completion"`
+	Hosts      []StaticHost     `mapstructure:"hosts"`
+	// Groups name lists of hosts and selectors for netssh multi (@name).
+	Groups map[string][]string `mapstructure:"groups"`
+	Multi  MultiConfig         `mapstructure:"multi"`
 }
 
 type ShellConfig struct {
@@ -37,6 +41,8 @@ type ResolverConfig struct {
 	Strategies        []string `mapstructure:"strategies"`
 	ManagementSubnets []string `mapstructure:"management_subnets"`
 	InterfaceName     string   `mapstructure:"interface_name"`
+	// HostnameDomain is appended by the hostname strategy to names without a dot.
+	HostnameDomain string `mapstructure:"hostname_domain"`
 }
 
 type CacheConfig struct {
@@ -114,7 +120,7 @@ func Load() (*Config, error) {
 	v.SetEnvPrefix("NETSSH")
 	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
 	v.AutomaticEnv()
-	for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shell.alias", "ssh.proxy_jump", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results"} {
+	for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "resolver.hostname_domain", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shell.alias", "ssh.proxy_jump", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results", "multi.multiplexer", "multi.panes_per_window"} {
 		if err := v.BindEnv(key); err != nil {
 			return nil, err
 		}
@@ -157,6 +163,12 @@ func Load() (*Config, error) {
 	if err := cfg.Shortcuts.Validate(); err != nil {
 		return nil, err
 	}
+	if err := cfg.ValidateHosts(); err != nil {
+		return nil, err
+	}
+	if err := cfg.ValidateMulti(); err != nil {
+		return nil, err
+	}
 	for i := range cfg.NetBoxes {
 		source := &cfg.NetBoxes[i]
 		source.Name = strings.ToLower(source.Name)

internal/config/hosts.go

@@ -0,0 +1,62 @@
+package config
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// StaticKind is the kind of hosts defined under hosts: instead of NetBox.
+const StaticKind = "static"
+
+// StaticHost is a host that is not in NetBox, defined in the config.
+type StaticHost struct {
+	Name    string     `mapstructure:"name"`
+	Address string     `mapstructure:"address"` // IP address or DNS name
+	User    string     `mapstructure:"user"`
+	Port    int        `mapstructure:"port"`
+	Tags    []string   `mapstructure:"tags"`
+	SSH     SSHOptions `mapstructure:"ssh"`
+}
+
+var staticHostName = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
+
+// ValidateHosts keeps static host names usable as selectors and addresses
+// safe to pass to ssh.
+func (c *Config) ValidateHosts() error {
+	seen := make(map[string]bool)
+	for i, host := range c.Hosts {
+		scope := fmt.Sprintf("hosts[%d]", i)
+		if !staticHostName.MatchString(host.Name) {
+			return fmt.Errorf("%s: name %q must start with a letter or digit and contain only letters, digits, dots, underscores, or hyphens", scope, host.Name)
+		}
+		name := strings.ToLower(host.Name)
+		if seen[name] {
+			return fmt.Errorf("%s: duplicate host name %q", scope, host.Name)
+		}
+		seen[name] = true
+		if host.Address == "" || strings.HasPrefix(host.Address, "-") || strings.ContainsAny(host.Address, " \t\n\r/@") {
+			return fmt.Errorf("%s: address %q must be an IP address or hostname", scope, host.Address)
+		}
+		if host.Port < 0 || host.Port > 65535 {
+			return fmt.Errorf("%s: port must be between 1 and 65535", scope)
+		}
+		if strings.HasPrefix(host.User, "-") || strings.ContainsAny(host.User, " \t\n\r@") {
+			return fmt.Errorf("%s: invalid user %q", scope, host.User)
+		}
+		if err := host.SSH.Validate(scope + ".ssh"); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// StaticHost returns the static host with the given name, or nil.
+func (c *Config) StaticHost(name string) *StaticHost {
+	for i := range c.Hosts {
+		if strings.EqualFold(c.Hosts[i].Name, name) {
+			return &c.Hosts[i]
+		}
+	}
+	return nil
+}

internal/config/instances.go

@@ -40,6 +40,9 @@ func (c *Config) ValidateNetBoxes() error {
 
 func (c *Config) HasNetBox() bool { return c.NetBox.URL != "" || len(c.NetBoxes) > 0 }
 
+// HasHosts reports whether netssh has anything to connect to: NetBox or static hosts.
+func (c *Config) HasHosts() bool { return c.HasNetBox() || len(c.Hosts) > 0 }
+
 // CachePath isolates named sources from legacy caches and from changed endpoints.
 // Rotating a token or reordering the sources does not discard usage history.
 func (c *Config) CachePath() string {

internal/config/multi.go

@@ -0,0 +1,92 @@
+package config
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// MultiConfig controls netssh multi.
+type MultiConfig struct {
+	// Multiplexer is auto, tmux, or zellij; empty means auto.
+	Multiplexer string `mapstructure:"multiplexer"`
+	// PanesPerWindow splits larger host lists into more windows or tabs; 0 = 9.
+	PanesPerWindow int `mapstructure:"panes_per_window"`
+	// SyncKey and SoloKey are tmux prefix keys for broadcast to all panes and
+	// for excluding the current pane; empty = default (S, e), "none" = off.
+	SyncKey string `mapstructure:"sync_key"`
+	SoloKey string `mapstructure:"solo_key"`
+}
+
+// Default tmux keys: unbound in a stock tmux (E would be "spread evenly").
+const (
+	DefaultSyncKey = "S"
+	DefaultSoloKey = "e"
+)
+
+// Keys returns the tmux keys to bind; "" for a disabled one.
+func (m MultiConfig) Keys() (sync, solo string) {
+	pick := func(key, fallback string) string {
+		switch key {
+		case "":
+			return fallback
+		case "none":
+			return ""
+		}
+		return key
+	}
+	return pick(m.SyncKey, DefaultSyncKey), pick(m.SoloKey, DefaultSoloKey)
+}
+
+var tmuxKey = regexp.MustCompile(`^([CMS]-)*([A-Za-z0-9]|F[0-9]{1,2}|[-_=+!@#$%^&*,./?<>\[\]]|Tab|Space|Enter|BSpace|Up|Down|Left|Right|Home|End|PPage|NPage)$`)
+
+// DefaultPanesPerWindow keeps panes readable on a normal screen (3×3).
+const DefaultPanesPerWindow = 9
+
+// ValidateMulti checks groups and the multi settings.
+func (c *Config) ValidateMulti() error {
+	switch c.Multi.Multiplexer {
+	case "", "auto", "tmux", "zellij":
+	default:
+		return fmt.Errorf("multi.multiplexer must be auto, tmux, or zellij")
+	}
+	if c.Multi.PanesPerWindow < 0 || c.Multi.PanesPerWindow > 64 {
+		return fmt.Errorf("multi.panes_per_window must be between 1 and 64")
+	}
+	for name, key := range map[string]string{"sync_key": c.Multi.SyncKey, "solo_key": c.Multi.SoloKey} {
+		if key != "" && key != "none" && !tmuxKey.MatchString(key) {
+			return fmt.Errorf("multi.%s %q is not a tmux key (e.g. S, e, C-s, F5) or none", name, key)
+		}
+	}
+	if sync, solo := c.Multi.Keys(); sync != "" && sync == solo {
+		return fmt.Errorf("multi.sync_key and multi.solo_key must differ")
+	}
+	names := make([]string, 0, len(c.Groups))
+	for name := range c.Groups {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		if !instanceName.MatchString(name) {
+			return fmt.Errorf("groups: name %q must contain only letters, digits, underscores, or hyphens", name)
+		}
+		if len(c.Groups[name]) == 0 {
+			return fmt.Errorf("groups.%s: needs at least one host or selector", name)
+		}
+		for _, selector := range c.Groups[name] {
+			if strings.TrimSpace(selector) == "" || strings.ContainsAny(selector, " \t\n") || strings.HasPrefix(selector, "-") {
+				return fmt.Errorf("groups.%s: invalid entry %q", name, selector)
+			}
+		}
+	}
+	return nil
+}
+
+// PanesPerWindowOrDefault returns the configured value or the default.
+func (m MultiConfig) PanesPerWindowOrDefault() int {
+	if m.PanesPerWindow > 0 {
+		return m.PanesPerWindow
+	}
+	return DefaultPanesPerWindow
+}

internal/config/ssh.go

@@ -169,7 +169,11 @@ func (o SSHOptions) Validate(scope string) error {
 // SSHOptionsFor merges global, instance, and matching rule options for host.
 func (c *Config) SSHOptionsFor(host SSHHost) SSHOptions {
 	merged := c.SSH.SSHOptions.merge(SSHOptions{})
-	if host.Instance == "" {
+	if host.Kind == StaticKind {
+		if static := c.StaticHost(host.Name); static != nil {
+			merged = merged.merge(static.SSH)
+		}
+	} else if host.Instance == "" {
 		merged = merged.merge(c.NetBox.SSH)
 	}
 	for _, source := range c.NetBoxes {

internal/config/ssh_test.go

@@ -135,3 +135,78 @@ func TestForwardsValidation(t *testing.T) {
 		}
 	}
 }
+
+func TestStaticHosts(t *testing.T) {
+	cfg, err := loadYAML(t, `
+resolver:
+  hostname_domain: example.com
+ssh:
+  proxy_jump: jh
+  rules:
+    - match: {kind: static, tag: home}
+      host_key_checking: off
+hosts:
+  - name: Router
+    address: 192.168.1.1
+    user: admin
+    port: 2222
+    tags: [home]
+    ssh:
+      proxy_jump: none
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !cfg.HasHosts() || cfg.HasNetBox() || cfg.Resolver.HostnameDomain != "example.com" {
+		t.Fatalf("got %+v", cfg)
+	}
+	host := cfg.StaticHost("router")
+	if host == nil || host.Address != "192.168.1.1" || host.User != "admin" || host.Port != 2222 {
+		t.Fatalf("host: %+v", host)
+	}
+	opts := cfg.SSHOptionsFor(SSHHost{Name: "Router", Kind: StaticKind, Tags: []string{"home"}})
+	if opts.ProxyJump != "none" || opts.HostKeyChecking != "off" {
+		t.Fatalf("static host options: %+v", opts)
+	}
+	// A NetBox host of the same name does not get the static host's options.
+	if got := cfg.SSHOptionsFor(SSHHost{Name: "Router", Kind: "device"}); got.ProxyJump != "jh" {
+		t.Fatalf("netbox host: %+v", got)
+	}
+}
+
+func TestStaticHostsValidation(t *testing.T) {
+	for _, hosts := range []string{
+		"- {name: a, address: 10.0.0.1}\n  - {name: A, address: 10.0.0.2}",
+		"- {name: 'bad name', address: 10.0.0.1}",
+		"- {name: prod/a, address: 10.0.0.1}",
+		"- {name: a}",
+		"- {name: a, address: '-oProxyCommand=x'}",
+		"- {name: a, address: 10.0.0.1, port: 70000}",
+		"- {name: a, address: 10.0.0.1, user: 'a b'}",
+		"- {name: a, address: 10.0.0.1, ssh: {target: nope}}",
+	} {
+		if _, err := loadYAML(t, "hosts:\n  "+hosts+"\n"); err == nil || !strings.Contains(err.Error(), "hosts[") {
+			t.Errorf("%s: got %v", hosts, err)
+		}
+	}
+}
+
+func TestMultiConfig(t *testing.T) {
+	cfg, err := loadYAML(t, "groups:\n  K8s: [master1, \"tag:worker\"]\nmulti:\n  multiplexer: zellij\n")
+	if err != nil || len(cfg.Groups["k8s"]) != 2 || cfg.Multi.Multiplexer != "zellij" || cfg.Multi.PanesPerWindowOrDefault() != 9 {
+		t.Fatalf("%+v %v", cfg, err)
+	}
+	if sync, solo := cfg.Multi.Keys(); sync != "S" || solo != "e" {
+		t.Fatalf("default keys %q %q", sync, solo)
+	}
+	custom, err := loadYAML(t, "multi: {sync_key: C-s, solo_key: none}\n")
+	if sync, solo := custom.Multi.Keys(); err != nil || sync != "C-s" || solo != "" {
+		t.Fatalf("custom keys %q %q %v", sync, solo, err)
+	}
+	for _, bad := range []string{"multi: {multiplexer: screen}", "multi: {panes_per_window: 100}", "groups: {web: []}", "groups: {web: [\"a b\"]}",
+		"multi: {sync_key: \"x y\"}", "multi: {sync_key: \"{\"}", "multi: {sync_key: e}"} {
+		if _, err := loadYAML(t, bad+"\n"); err == nil {
+			t.Errorf("%s accepted", bad)
+		}
+	}
+}

internal/multiplex/multiplex.go

@@ -0,0 +1,251 @@
+// Package multiplex opens several commands side by side in tmux or zellij.
+package multiplex
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+)
+
+// Pane is one command shown in its own pane.
+type Pane struct {
+	Title string
+	Argv  []string
+}
+
+// Options control how panes are laid out.
+type Options struct {
+	Label     string // window, session, and tab name
+	Sync      bool   // type into all panes of a window at once
+	PerWindow int    // panes per tmux window or zellij tab
+	LayoutDir string // where zellij layout files and tmux key bindings are written
+	// SyncKey and SoloKey are tmux prefix keys that toggle broadcast for the
+	// window and exclude the current pane from it; empty means no binding.
+	SyncKey, SoloKey string
+	// Hint receives notes for the user before the process is replaced.
+	Hint func(string)
+}
+
+// Runner executes multiplexer commands; tests and --dry-run replace it.
+type Runner interface {
+	// Output runs argv and returns its trimmed standard output.
+	Output(argv ...string) (string, error)
+	// Exec replaces the current process with argv.
+	Exec(argv ...string) error
+	LookPath(name string) (string, error)
+	Getenv(key string) string
+	WriteFile(path string, data []byte) error
+}
+
+// Supported multiplexers.
+const (
+	Tmux   = "tmux"
+	Zellij = "zellij"
+)
+
+// ErrNone means neither tmux nor zellij is available.
+var ErrNone = errors.New("netssh multi needs tmux or zellij; install one of them (e.g. apt install tmux)")
+
+// Detect picks the multiplexer: the requested one, else the one netssh runs
+// in, else tmux, else zellij.
+func Detect(requested string, r Runner) (string, error) {
+	switch requested {
+	case Tmux, Zellij:
+		if _, err := r.LookPath(requested); err != nil {
+			return "", fmt.Errorf("%s is not installed", requested)
+		}
+		return requested, nil
+	case "", "auto":
+	default:
+		return "", fmt.Errorf("unknown multiplexer %q", requested)
+	}
+	if r.Getenv("TMUX") != "" {
+		return Tmux, nil
+	}
+	if r.Getenv("ZELLIJ") != "" {
+		return Zellij, nil
+	}
+	for _, name := range []string{Tmux, Zellij} {
+		if _, err := r.LookPath(name); err == nil {
+			return name, nil
+		}
+	}
+	return "", ErrNone
+}
+
+// Open shows panes in the multiplexer. Outside of it, Open replaces the
+// process with the multiplexer client and only returns on error.
+func Open(kind string, panes []Pane, opts Options, r Runner) error {
+	if len(panes) == 0 {
+		return errors.New("no hosts to open")
+	}
+	if opts.Hint == nil {
+		opts.Hint = func(string) {}
+	}
+	if opts.PerWindow <= 0 {
+		opts.PerWindow = 9
+	}
+	if opts.Label == "" {
+		opts.Label = "netssh"
+	}
+	switch kind {
+	case Tmux:
+		return openTmux(panes, opts, r)
+	case Zellij:
+		return openZellij(panes, opts, r)
+	}
+	return fmt.Errorf("unknown multiplexer %q", kind)
+}
+
+// ToggleSync switches broadcast input in the current tmux window or zellij
+// tab; with pane it excludes the current tmux pane from it or includes it again.
+func ToggleSync(r Runner, pane bool) (string, error) {
+	if pane {
+		if r.Getenv("TMUX") == "" {
+			if r.Getenv("ZELLIJ") != "" {
+				return "", errors.New("zellij broadcasts to a whole tab; single panes cannot be excluded")
+			}
+			return "", errors.New("netssh sync --pane works inside tmux")
+		}
+		solo, err := r.Output("tmux", "display-message", "-p", "#{@netssh_solo}")
+		if err != nil {
+			return "", err
+		}
+		for _, argv := range soloToggle(solo == "1") {
+			if _, err := r.Output(argv...); err != nil {
+				return "", err
+			}
+		}
+		if solo == "1" {
+			return "pane included in broadcast", nil
+		}
+		return "pane excluded from broadcast", nil
+	}
+	switch {
+	case r.Getenv("TMUX") != "":
+		current, err := r.Output("tmux", "show-window-options", "-v", "synchronize-panes")
+		if err != nil {
+			return "", err
+		}
+		next := "on"
+		if current == "on" {
+			next = "off"
+		}
+		if _, err := r.Output("tmux", "set-window-option", "synchronize-panes", next); err != nil {
+			return "", err
+		}
+		return "broadcast " + next, nil
+	case r.Getenv("ZELLIJ") != "":
+		if _, err := r.Output("zellij", "action", "toggle-active-sync-tab"); err != nil {
+			return "", err
+		}
+		return "broadcast toggled", nil
+	}
+	return "", errors.New("netssh sync works inside tmux or zellij")
+}
+
+// chunks splits panes into groups of at most n.
+func chunks(panes []Pane, n int) [][]Pane {
+	var out [][]Pane
+	for len(panes) > n {
+		out = append(out, panes[:n])
+		panes = panes[n:]
+	}
+	return append(out, panes)
+}
+
+// windowLabel numbers windows when the panes need more than one.
+func windowLabel(label string, i, total int) string {
+	if total == 1 {
+		return label
+	}
+	return fmt.Sprintf("%s-%d", label, i+1)
+}
+
+// System runs real commands.
+type System struct{}
+
+func (System) Output(argv ...string) (string, error) {
+	cmd := exec.Command(argv[0], argv[1:]...)
+	var stderr strings.Builder
+	cmd.Stderr = &stderr
+	out, err := cmd.Output()
+	if err != nil {
+		if msg := strings.TrimSpace(stderr.String()); msg != "" {
+			return "", fmt.Errorf("%s: %s", argv[0], msg)
+		}
+		return "", fmt.Errorf("%s: %w", argv[0], err)
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+func (System) Exec(argv ...string) error {
+	path, err := exec.LookPath(argv[0])
+	if err != nil {
+		return err
+	}
+	return syscall.Exec(path, argv, os.Environ())
+}
+
+func (System) LookPath(name string) (string, error) { return exec.LookPath(name) }
+func (System) Getenv(key string) string             { return os.Getenv(key) }
+func (System) WriteFile(path string, data []byte) error {
+	return os.WriteFile(path, data, 0o600)
+}
+
+// DryRun prints commands instead of running them; Output returns fake IDs.
+type DryRun struct {
+	W   io.Writer
+	Env map[string]string // values for Getenv, e.g. TMUX
+	n   int
+}
+
+func (d *DryRun) Output(argv ...string) (string, error) {
+	fmt.Fprintln(d.W, shellJoin(argv))
+	d.n++
+	switch {
+	case len(argv) > 1 && (argv[1] == "new-window" || argv[1] == "new-session"):
+		return fmt.Sprintf("@%d %%%d", d.n, d.n), nil
+	case len(argv) > 1 && argv[1] == "split-window":
+		return fmt.Sprintf("%%%d", d.n), nil
+	case len(argv) > 1 && argv[1] == "has-session":
+		return "", errors.New("no session")
+	}
+	return "", nil
+}
+
+func (d *DryRun) Exec(argv ...string) error {
+	fmt.Fprintln(d.W, shellJoin(argv))
+	return nil
+}
+
+// LookPath pretends every multiplexer is installed, so --dry-run shows the
+// commands on machines without tmux or zellij.
+func (d *DryRun) LookPath(name string) (string, error) { return name, nil }
+func (d *DryRun) Getenv(key string) string {
+	if v, ok := d.Env[key]; ok {
+		return v
+	}
+	return os.Getenv(key)
+}
+func (d *DryRun) WriteFile(path string, data []byte) error {
+	fmt.Fprintf(d.W, "# %s\n%s", path, data)
+	return nil
+}
+
+// shellJoin quotes argv for display.
+func shellJoin(argv []string) string {
+	quoted := make([]string, len(argv))
+	for i, arg := range argv {
+		if arg != "" && strings.Trim(arg, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@%+=:,./_-") == "" {
+			quoted[i] = arg
+			continue
+		}
+		quoted[i] = "'" + strings.ReplaceAll(arg, "'", `'\''`) + "'"
+	}
+	return strings.Join(quoted, " ")
+}

internal/multiplex/multiplex_test.go

@@ -0,0 +1,281 @@
+package multiplex
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// fake records commands and answers like tmux and zellij would.
+type fake struct {
+	env       map[string]string
+	installed map[string]bool
+	sessions  map[string]bool
+	calls     []string
+	exec      []string
+	files     map[string]string
+	syncState string
+	keys      map[string]string // existing prefix bindings by key
+	solo      string
+	n         int
+}
+
+func newFake(env map[string]string, installed ...string) *fake {
+	f := &fake{env: env, installed: map[string]bool{}, sessions: map[string]bool{}, files: map[string]string{}, syncState: "off"}
+	for _, name := range installed {
+		f.installed[name] = true
+	}
+	return f
+}
+
+func (f *fake) Output(argv ...string) (string, error) {
+	f.calls = append(f.calls, strings.Join(argv, " "))
+	f.n++
+	switch argv[1] {
+	case "new-window", "new-session":
+		return fmt.Sprintf("@%d %%%d", f.n, f.n), nil
+	case "split-window":
+		return fmt.Sprintf("%%%d", f.n), nil
+	case "has-session":
+		if f.sessions[strings.TrimPrefix(argv[3], "=")] {
+			return "", nil
+		}
+		return "", errors.New("can't find session")
+	case "show-window-options":
+		return f.syncState, nil
+	case "list-keys":
+		return f.keys[argv[4]], nil
+	case "display-message":
+		return f.solo, nil
+	}
+	return "", nil
+}
+func (f *fake) Exec(argv ...string) error { f.exec = argv; return nil }
+func (f *fake) LookPath(name string) (string, error) {
+	if f.installed[name] {
+		return "/usr/bin/" + name, nil
+	}
+	return "", errors.New("not found")
+}
+func (f *fake) Getenv(key string) string { return f.env[key] }
+func (f *fake) WriteFile(path string, data []byte) error {
+	f.files[path] = string(data)
+	return nil
+}
+
+func panes(names ...string) []Pane {
+	out := make([]Pane, 0, len(names))
+	for _, name := range names {
+		out = append(out, Pane{Title: name, Argv: []string{"/usr/bin/netssh", name}})
+	}
+	return out
+}
+
+func TestDetect(t *testing.T) {
+	for _, tc := range []struct {
+		requested string
+		env       map[string]string
+		installed []string
+		want      string
+	}{
+		{"", map[string]string{"TMUX": "/tmp/tmux"}, []string{"tmux", "zellij"}, Tmux},
+		{"auto", map[string]string{"ZELLIJ": "0"}, []string{"tmux", "zellij"}, Zellij},
+		{"", nil, []string{"tmux", "zellij"}, Tmux},
+		{"", nil, []string{"zellij"}, Zellij},
+		{"zellij", map[string]string{"TMUX": "x"}, []string{"tmux", "zellij"}, Zellij},
+	} {
+		got, err := Detect(tc.requested, newFake(tc.env, tc.installed...))
+		if err != nil || got != tc.want {
+			t.Errorf("%+v: got %q %v", tc, got, err)
+		}
+	}
+	if _, err := Detect("", newFake(nil)); !errors.Is(err, ErrNone) {
+		t.Errorf("nothing installed: %v", err)
+	}
+	if _, err := Detect("tmux", newFake(nil, "zellij")); err == nil {
+		t.Error("missing requested multiplexer accepted")
+	}
+}
+
+func TestTmuxInside(t *testing.T) {
+	f := newFake(map[string]string{"TMUX": "/tmp/tmux-1/default"}, "tmux")
+	if err := Open(Tmux, panes("a", "b", "c"), Options{Label: "pve", Sync: true, SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l"}, f); err != nil {
+		t.Fatal(err)
+	}
+	script := "sh -c " + paneScript + " netssh-pane /usr/bin/netssh "
+	want := []string{
+		"tmux new-window -P -F #{window_id} #{pane_id} -n pve " + script + "a",
+		"tmux split-window -t @1 -P -F #{pane_id} " + script + "b",
+		"tmux select-layout -t @1 tiled",
+		"tmux split-window -t @1 -P -F #{pane_id} " + script + "c",
+		"tmux select-layout -t @1 tiled",
+		"tmux set-option -p -t %1 @netssh_host a",
+		"tmux set-option -p -t %2 @netssh_host b",
+		"tmux set-option -p -t %4 @netssh_host c",
+		"tmux set-window-option -t @1 @netssh 1",
+		"tmux set-window-option -t @1 pane-border-status top",
+		"tmux set-window-option -t @1 pane-border-format  #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} ",
+		"tmux set-window-option -t @1 synchronize-panes on",
+		"tmux show-options -gv prefix",
+		"tmux list-keys -T prefix S",
+		"tmux list-keys -T prefix e",
+		"tmux source-file /tmp/l/netssh-multi.tmux.conf",
+		"tmux select-window -t @1",
+	}
+	if strings.Join(f.calls, "\n") != strings.Join(want, "\n") {
+		t.Fatalf("calls:\n%s\nwant:\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n"))
+	}
+	if f.exec != nil {
+		t.Fatal("inside tmux must not attach")
+	}
+}
+
+func TestTmuxOutsideSplitsWindowsAndAvoidsSessionNames(t *testing.T) {
+	f := newFake(nil, "tmux")
+	f.sessions["netssh-pve"] = true
+	var hints []string
+	err := Open(Tmux, panes("a", "b", "c"), Options{Label: "pve", PerWindow: 2, Hint: func(s string) { hints = append(hints, s) }}, f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	joined := strings.Join(f.calls, "\n")
+	for _, want := range []string{
+		"tmux has-session -t =netssh-pve-2",
+		"tmux new-session -d -x 240 -y 70 -s netssh-pve-2 -P -F #{window_id} #{pane_id} -n pve-1 ",
+		"tmux new-window -t netssh-pve-2: -P -F #{window_id} #{pane_id} -n pve-2 ",
+		"tmux set-option -t netssh-pve-2 status-left-length 40",
+	} {
+		if !strings.Contains(joined, want) {
+			t.Errorf("missing %q in\n%s", want, joined)
+		}
+	}
+	if strings.Contains(joined, "synchronize-panes") {
+		t.Error("sync set without --sync")
+	}
+	if strings.Join(f.exec, " ") != "tmux attach-session -t netssh-pve-2" || len(hints) != 1 {
+		t.Fatalf("exec %v hints %v", f.exec, hints)
+	}
+}
+
+func TestZellijOutsideWritesGridLayout(t *testing.T) {
+	f := newFake(nil, "zellij")
+	if err := Open(Zellij, panes("a", "b", "c", `q"x`), Options{Label: "pve", LayoutDir: "/tmp/l"}, f); err != nil {
+		t.Fatal(err)
+	}
+	layout := f.files["/tmp/l/netssh-multi.kdl"]
+	for _, want := range []string{
+		`plugin location="zellij:tab-bar"`,
+		`tab name="pve" focus=true {`,
+		`pane split_direction="vertical" {`,
+		`pane name="a" command="/usr/bin/netssh" {`,
+		`args "a"`,
+		`pane name="q\"x" command="/usr/bin/netssh" {`,
+	} {
+		if !strings.Contains(layout, want) {
+			t.Errorf("layout lacks %q:\n%s", want, layout)
+		}
+	}
+	// 4 panes → 2 columns × 2 rows.
+	if n := strings.Count(layout, `split_direction="vertical"`); n != 2 {
+		t.Errorf("%d rows, want 2:\n%s", n, layout)
+	}
+	if strings.Join(f.exec, " ") != "zellij --layout /tmp/l/netssh-multi.kdl" {
+		t.Fatalf("exec %v", f.exec)
+	}
+}
+
+func TestZellijInsideAddsTabs(t *testing.T) {
+	f := newFake(map[string]string{"ZELLIJ": "0"}, "zellij")
+	if err := Open(Zellij, panes("a", "b", "c"), Options{Label: "pve", PerWindow: 2, Sync: true, LayoutDir: "/tmp/l"}, f); err != nil {
+		t.Fatal(err)
+	}
+	want := []string{
+		"zellij action new-tab --layout /tmp/l/netssh-multi-1.kdl",
+		"zellij action toggle-active-sync-tab",
+		"zellij action new-tab --layout /tmp/l/netssh-multi-2.kdl",
+		"zellij action toggle-active-sync-tab",
+	}
+	if strings.Join(f.calls, "\n") != strings.Join(want, "\n") {
+		t.Fatalf("calls:\n%s", strings.Join(f.calls, "\n"))
+	}
+	if !strings.Contains(f.files["/tmp/l/netssh-multi-2.kdl"], `tab name="pve-2"`) {
+		t.Fatalf("second tab: %s", f.files["/tmp/l/netssh-multi-2.kdl"])
+	}
+}
+
+func TestToggleSync(t *testing.T) {
+	f := newFake(map[string]string{"TMUX": "x"})
+	if state, err := ToggleSync(f, false); err != nil || state != "broadcast on" || f.calls[1] != "tmux set-window-option synchronize-panes on" {
+		t.Fatalf("%q %v %v", state, err, f.calls)
+	}
+	f.syncState = "on"
+	if state, _ := ToggleSync(f, false); state != "broadcast off" {
+		t.Fatalf("%q", state)
+	}
+	z := newFake(map[string]string{"ZELLIJ": "0"})
+	if _, err := ToggleSync(z, false); err != nil || z.calls[0] != "zellij action toggle-active-sync-tab" {
+		t.Fatalf("%v %v", err, z.calls)
+	}
+	if _, err := ToggleSync(newFake(nil), false); err == nil {
+		t.Fatal("outside a multiplexer accepted")
+	}
+}
+
+func TestTmuxKeyBindings(t *testing.T) {
+	f := newFake(map[string]string{"TMUX": "x"}, "tmux")
+	var hint string
+	if err := Open(Tmux, panes("a"), Options{SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l", Hint: func(s string) { hint = s }}, f); err != nil {
+		t.Fatal(err)
+	}
+	conf := f.files["/tmp/l/netssh-multi.tmux.conf"]
+	for _, want := range []string{"bind-key -T prefix S if-shell -F '#{@netssh}'", "bind-key -T prefix e if-shell", "set-option -p synchronize-panes off"} {
+		if !strings.Contains(conf, want) {
+			t.Errorf("conf lacks %q:\n%s", want, conf)
+		}
+	}
+	if hint != "keys: C-b S broadcast to all panes, C-b e exclude/include this pane" {
+		t.Errorf("hint %q", hint)
+	}
+
+	// A key bound in the user's tmux.conf is left alone; netssh's own is replaced.
+	f = newFake(map[string]string{"TMUX": "x"}, "tmux")
+	f.keys = map[string]string{"S": "bind-key -T prefix S kill-server", "e": "bind-key -T prefix e if-shell -F #{@netssh} …"}
+	if err := Open(Tmux, panes("a"), Options{SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l", Hint: func(s string) { hint = s }}, f); err != nil {
+		t.Fatal(err)
+	}
+	conf = f.files["/tmp/l/netssh-multi.tmux.conf"]
+	if strings.Contains(conf, "prefix S ") || !strings.Contains(conf, "prefix e ") {
+		t.Errorf("user binding overwritten or own binding not refreshed:\n%s", conf)
+	}
+	if !strings.Contains(hint, "C-b S kept your own binding") {
+		t.Errorf("hint %q", hint)
+	}
+
+	// No keys configured: nothing is bound.
+	f = newFake(map[string]string{"TMUX": "x"}, "tmux")
+	if err := Open(Tmux, panes("a"), Options{LayoutDir: "/tmp/l"}, f); err != nil {
+		t.Fatal(err)
+	}
+	if len(f.files) != 0 || strings.Contains(strings.Join(f.calls, "\n"), "source-file") {
+		t.Errorf("bound keys although disabled: %v", f.calls)
+	}
+}
+
+func TestToggleSyncPane(t *testing.T) {
+	f := newFake(map[string]string{"TMUX": "x"})
+	if state, err := ToggleSync(f, true); err != nil || state != "pane excluded from broadcast" {
+		t.Fatalf("%q %v", state, err)
+	}
+	if got := strings.Join(f.calls[1:], "; "); got != "tmux set-option -p synchronize-panes off; tmux set-option -p @netssh_solo 1" {
+		t.Fatalf("exclude: %s", got)
+	}
+	f = newFake(map[string]string{"TMUX": "x"})
+	f.solo = "1"
+	if state, _ := ToggleSync(f, true); state != "pane included in broadcast" || f.calls[1] != "tmux set-option -pu synchronize-panes" {
+		t.Fatalf("include: %q %v", state, f.calls)
+	}
+	if _, err := ToggleSync(newFake(map[string]string{"ZELLIJ": "0"}), true); err == nil || !strings.Contains(err.Error(), "whole tab") {
+		t.Fatalf("zellij: %v", err)
+	}
+}

internal/multiplex/tmux.go

@@ -0,0 +1,194 @@
+package multiplex
+
+import (
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// paneScript runs the pane's command and keeps a failed one on screen, so an
+// unreachable host shows its error instead of the pane vanishing.
+const paneScript = `"$@"; status=$?; if [ "$status" -ne 0 ]; then echo; echo "netssh exited with status $status, press Enter to close"; read -r _; fi`
+
+// tmuxArgv runs the pane through sh with argv as arguments: no quoting, and
+// independent of the user's default-shell (which may be fish).
+func tmuxArgv(p Pane) []string {
+	return append([]string{"sh", "-c", paneScript, "netssh-pane"}, p.Argv...)
+}
+
+// openTmux adds a window per chunk of panes: to the current session inside
+// tmux, else to a new detached session that is attached at the end.
+func openTmux(panes []Pane, opts Options, r Runner) error {
+	inside := r.Getenv("TMUX") != ""
+	session := ""
+	if !inside {
+		session = freeSession(r, "netssh-"+opts.Label)
+	}
+	groups := chunks(panes, opts.PerWindow)
+	first := ""
+	for i, group := range groups {
+		name := windowLabel(opts.Label, i, len(groups))
+		format := []string{"-P", "-F", "#{window_id} #{pane_id}", "-n", name}
+		var create []string
+		switch {
+		case inside:
+			create = append([]string{"tmux", "new-window"}, format...)
+		case i == 0:
+			// A large virtual size leaves room for the splits; attaching resizes it.
+			create = append([]string{"tmux", "new-session", "-d", "-x", "240", "-y", "70", "-s", session}, format...)
+		default:
+			create = append([]string{"tmux", "new-window", "-t", session + ":"}, format...)
+		}
+		out, err := r.Output(append(create, tmuxArgv(group[0])...)...)
+		if err != nil {
+			return err
+		}
+		if !inside && i == 0 {
+			// tmux cuts the status bar's session name at 10 characters
+			// ("[netssh-pv"); widen it for this session only.
+			if _, err := r.Output("tmux", "set-option", "-t", session, "status-left-length", "40"); err != nil {
+				return err
+			}
+		}
+		window, pane, _ := strings.Cut(out, " ")
+		if first == "" {
+			first = window
+		}
+		paneIDs := []string{pane}
+		for _, p := range group[1:] {
+			id, err := r.Output(append([]string{"tmux", "split-window", "-t", window, "-P", "-F", "#{pane_id}"}, tmuxArgv(p)...)...)
+			if err != nil {
+				return err
+			}
+			paneIDs = append(paneIDs, id)
+			// Re-tile after every split so the next one still has room.
+			if _, err := r.Output("tmux", "select-layout", "-t", window, "tiled"); err != nil {
+				return err
+			}
+		}
+		for j, id := range paneIDs {
+			// A pane may already be gone (host unreachable and closed); not fatal.
+			_, _ = r.Output("tmux", "set-option", "-p", "-t", id, "@netssh_host", group[j].Title)
+		}
+		windowOptions := [][]string{
+			{"@netssh", "1"}, // the key bindings act only in these windows
+			{"pane-border-status", "top"},
+			{"pane-border-format", " #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} "},
+		}
+		if opts.Sync {
+			windowOptions = append(windowOptions, []string{"synchronize-panes", "on"})
+		}
+		for _, option := range windowOptions {
+			if _, err := r.Output("tmux", "set-window-option", "-t", window, option[0], option[1]); err != nil {
+				return err
+			}
+		}
+	}
+	keys, err := bindKeys(r, opts)
+	if err != nil {
+		return err
+	}
+	if keys != "" {
+		opts.Hint(keys)
+	}
+	if inside {
+		_, err := r.Output("tmux", "select-window", "-t", first)
+		return err
+	}
+	return r.Exec("tmux", "attach-session", "-t", session)
+}
+
+// soloToggle excludes the current pane from broadcast (a pane-level
+// synchronize-panes off) or includes it again by removing that override.
+func soloToggle(solo bool) [][]string {
+	if solo {
+		return [][]string{
+			{"tmux", "set-option", "-pu", "synchronize-panes"},
+			{"tmux", "set-option", "-pu", "@netssh_solo"},
+		}
+	}
+	return [][]string{
+		{"tmux", "set-option", "-p", "synchronize-panes", "off"},
+		{"tmux", "set-option", "-p", "@netssh_solo", "1"},
+	}
+}
+
+// keyBindings toggle broadcast in netssh multi windows; elsewhere they only
+// show a message, so they do not change what the keys mean to other windows.
+const syncBinding = `bind-key -T prefix %s if-shell -F '#{@netssh}' {
+  set-window-option synchronize-panes
+  display-message 'netssh: broadcast #{?synchronize-panes,on,off}'
+} {
+  display-message 'netssh: not a netssh multi window'
+}
+`
+
+const soloBinding = `bind-key -T prefix %s if-shell -F '#{@netssh}' {
+  if-shell -F '#{@netssh_solo}' {
+    set-option -pu synchronize-panes
+    set-option -pu @netssh_solo
+    display-message 'netssh: pane included in broadcast'
+  } {
+    set-option -p synchronize-panes off
+    set-option -p @netssh_solo 1
+    display-message 'netssh: pane excluded from broadcast'
+  }
+} {
+  display-message 'netssh: not a netssh multi window'
+}
+`
+
+// bindKeys installs the broadcast keys in the tmux server unless the user's
+// own configuration already uses them, and returns a hint naming the keys.
+func bindKeys(r Runner, opts Options) (string, error) {
+	prefix, err := r.Output("tmux", "show-options", "-gv", "prefix")
+	if err != nil || prefix == "" {
+		prefix = "C-b"
+	}
+	var conf strings.Builder
+	var hints, taken []string
+	for _, key := range []struct{ key, binding, what string }{
+		{opts.SyncKey, syncBinding, "broadcast to all panes"},
+		{opts.SoloKey, soloBinding, "exclude/include this pane"},
+	} {
+		if key.key == "" {
+			continue
+		}
+		// An existing binding is replaced only if netssh made it.
+		if existing, _ := r.Output("tmux", "list-keys", "-T", "prefix", key.key); existing != "" && !strings.Contains(existing, "@netssh") {
+			taken = append(taken, prefix+" "+key.key)
+			continue
+		}
+		fmt.Fprintf(&conf, key.binding, key.key)
+		hints = append(hints, prefix+" "+key.key+" "+key.what)
+	}
+	if conf.Len() > 0 {
+		path := filepath.Join(opts.LayoutDir, "netssh-multi.tmux.conf")
+		if err := r.WriteFile(path, []byte(conf.String())); err != nil {
+			return "", err
+		}
+		if _, err := r.Output("tmux", "source-file", path); err != nil {
+			return "", err
+		}
+	}
+	hint := "keys: " + strings.Join(hints, ", ")
+	if len(hints) == 0 {
+		hint = "toggle broadcast with: netssh sync, netssh sync --pane"
+	}
+	if len(taken) > 0 {
+		hint += "; " + strings.Join(taken, " and ") + " kept your own binding (use netssh sync)"
+	}
+	return hint, nil
+}
+
+// freeSession returns name, or name-2, name-3, … if a session already uses it.
+func freeSession(r Runner, name string) string {
+	candidate := name
+	for n := 2; ; n++ {
+		if _, err := r.Output("tmux", "has-session", "-t", "="+candidate); err != nil {
+			return candidate
+		}
+		candidate = name + "-" + strconv.Itoa(n)
+	}
+}

internal/multiplex/zellij.go

@@ -0,0 +1,101 @@
+package multiplex
+
+import (
+	"fmt"
+	"math"
+	"path/filepath"
+	"strings"
+)
+
+// openZellij writes a layout with one tab per chunk of panes. Inside zellij
+// each tab is added to the current session; outside, a new session starts.
+func openZellij(panes []Pane, opts Options, r Runner) error {
+	groups := chunks(panes, opts.PerWindow)
+	if r.Getenv("ZELLIJ") != "" {
+		for i, group := range groups {
+			path := filepath.Join(opts.LayoutDir, fmt.Sprintf("netssh-multi-%d.kdl", i+1))
+			tab := zellijTab(windowLabel(opts.Label, i, len(groups)), group, true)
+			if err := r.WriteFile(path, []byte(zellijLayout(tab))); err != nil {
+				return err
+			}
+			if _, err := r.Output("zellij", "action", "new-tab", "--layout", path); err != nil {
+				return err
+			}
+			if opts.Sync {
+				if _, err := r.Output("zellij", "action", "toggle-active-sync-tab"); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	var tabs strings.Builder
+	for i, group := range groups {
+		tabs.WriteString(zellijTab(windowLabel(opts.Label, i, len(groups)), group, i == 0))
+	}
+	path := filepath.Join(opts.LayoutDir, "netssh-multi.kdl")
+	if err := r.WriteFile(path, []byte(zellijLayout(tabs.String()))); err != nil {
+		return err
+	}
+	if opts.Sync {
+		opts.Hint("zellij starts without broadcast: press Ctrl+t, then s, to type into all panes")
+	} else {
+		opts.Hint("toggle broadcast with Ctrl+t, then s (or netssh sync)")
+	}
+	return r.Exec("zellij", "--layout", path)
+}
+
+// zellijLayout wraps tabs with zellij's tab and status bars.
+func zellijLayout(tabs string) string {
+	return `layout {
+    default_tab_template {
+        pane size=1 borderless=true {
+            plugin location="zellij:tab-bar"
+        }
+        children
+        pane size=2 borderless=true {
+            plugin location="zellij:status-bar"
+        }
+    }
+` + tabs + "}\n"
+}
+
+// zellijTab arranges panes in a grid: rows of ceil(sqrt(n)) columns.
+func zellijTab(name string, panes []Pane, focus bool) string {
+	cols := int(math.Ceil(math.Sqrt(float64(len(panes)))))
+	var b strings.Builder
+	fmt.Fprintf(&b, "    tab name=%s", kdlString(name))
+	if focus {
+		b.WriteString(" focus=true")
+	}
+	b.WriteString(" {\n")
+	for start := 0; start < len(panes); start += cols {
+		row := panes[start:min(start+cols, len(panes))]
+		indent := "        "
+		if len(row) > 1 {
+			b.WriteString(indent + "pane split_direction=\"vertical\" {\n")
+			indent += "    "
+		}
+		for _, p := range row {
+			fmt.Fprintf(&b, "%spane name=%s command=%s {\n", indent, kdlString(p.Title), kdlString(p.Argv[0]))
+			if len(p.Argv) > 1 {
+				args := make([]string, 0, len(p.Argv)-1)
+				for _, arg := range p.Argv[1:] {
+					args = append(args, kdlString(arg))
+				}
+				fmt.Fprintf(&b, "%s    args %s\n", indent, strings.Join(args, " "))
+			}
+			b.WriteString(indent + "}\n")
+		}
+		if len(row) > 1 {
+			b.WriteString("        }\n")
+		}
+	}
+	b.WriteString("    }\n")
+	return b.String()
+}
+
+// kdlString quotes s as a KDL string.
+func kdlString(s string) string {
+	return `"` + strings.NewReplacer(`\`, `\\`, `"`, `\"`, "\n", `\n`).Replace(s) + `"`
+}

internal/netbox/client.go

@@ -105,6 +105,22 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
 	if opts.Kind != "" && opts.Kind != "device" && opts.Kind != "vm" {
 		return nil, fmt.Errorf("invalid host kind %q", opts.Kind)
 	}
+	filters := ""
+	if opts.Tag != "" {
+		filters += "&tag=" + url.QueryEscape(opts.Tag)
+	}
+	if opts.Cluster != "" {
+		ids, err := c.clusterIDs(ctx, opts.Cluster)
+		if err != nil {
+			return nil, fmt.Errorf("clusters: %w", err)
+		}
+		if len(ids) == 0 {
+			return nil, nil // no such cluster in this NetBox
+		}
+		for _, id := range ids {
+			filters += fmt.Sprintf("&cluster_id=%d", id)
+		}
+	}
 	var (
 		mu      sync.Mutex
 		results []HostEntry
@@ -116,7 +132,7 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			devices, err := c.fetchAllDevices(ctx, query, opts.Tag)
+			devices, err := c.fetchAllDevices(ctx, query, filters)
 			mu.Lock()
 			defer mu.Unlock()
 			if err != nil {
@@ -131,7 +147,7 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			vms, err := c.fetchAllVMs(ctx, query, opts.Tag)
+			vms, err := c.fetchAllVMs(ctx, query, filters)
 			mu.Lock()
 			defer mu.Unlock()
 			if err != nil {
@@ -231,15 +247,27 @@ func (c *Client) searchVMs(ctx context.Context, query, tag string) ([]HostEntry,
 	return entries, nil
 }
 
-func (c *Client) fetchAllDevices(ctx context.Context, query, tag string) ([]HostEntry, error) {
+// clusterIDs returns the IDs of the clusters named name (case-insensitive).
+func (c *Client) clusterIDs(ctx context.Context, name string) ([]int, error) {
+	var resp netboxListResponse[netboxCluster]
+	apiURL := fmt.Sprintf("%s/api/virtualization/clusters/?name__ie=%s&limit=50", c.baseURL, url.QueryEscape(name))
+	if err := c.get(ctx, apiURL, &resp); err != nil {
+		return nil, err
+	}
+	ids := make([]int, 0, len(resp.Results))
+	for _, cluster := range resp.Results {
+		ids = append(ids, cluster.ID)
+	}
+	return ids, nil
+}
+
+// fetchAllDevices pages through devices; filters are extra "&key=value" parameters.
+func (c *Client) fetchAllDevices(ctx context.Context, query, filters string) ([]HostEntry, error) {
 	const pageSize = 50
 	var all []HostEntry
 	for offset := 0; ; offset += pageSize {
 		apiURL := fmt.Sprintf("%s/api/dcim/devices/?name__ic=%s&limit=%d&offset=%d",
-			c.baseURL, url.QueryEscape(query), pageSize, offset)
-		if tag != "" {
-			apiURL += "&tag=" + url.QueryEscape(tag)
-		}
+			c.baseURL, url.QueryEscape(query), pageSize, offset) + filters
 		var resp netboxListResponse[netboxDevice]
 		if err := c.get(ctx, apiURL, &resp); err != nil {
 			return nil, err
@@ -254,15 +282,12 @@ func (c *Client) fetchAllDevices(ctx context.Context, query, tag string) ([]Host
 	return all, nil
 }
 
-func (c *Client) fetchAllVMs(ctx context.Context, query, tag string) ([]HostEntry, error) {
+func (c *Client) fetchAllVMs(ctx context.Context, query, filters string) ([]HostEntry, error) {
 	const pageSize = 50
 	var all []HostEntry
 	for offset := 0; ; offset += pageSize {
 		apiURL := fmt.Sprintf("%s/api/virtualization/virtual-machines/?name__ic=%s&limit=%d&offset=%d",
-			c.baseURL, url.QueryEscape(query), pageSize, offset)
-		if tag != "" {
-			apiURL += "&tag=" + url.QueryEscape(tag)
-		}
+			c.baseURL, url.QueryEscape(query), pageSize, offset) + filters
 		var resp netboxListResponse[netboxVM]
 		if err := c.get(ctx, apiURL, &resp); err != nil {
 			return nil, err
@@ -343,6 +368,9 @@ func deviceToEntry(d netboxDevice) HostEntry {
 	for _, t := range d.Tags {
 		e.Tags = append(e.Tags, t.Name)
 	}
+	if d.Cluster != nil {
+		e.Cluster = d.Cluster.Name
+	}
 	return e
 }
 
@@ -357,6 +385,9 @@ func vmToEntry(v netboxVM) HostEntry {
 	for _, t := range v.Tags {
 		e.Tags = append(e.Tags, t.Name)
 	}
+	if v.Cluster != nil {
+		e.Cluster = v.Cluster.Name
+	}
 	return e
 }
 

internal/netbox/client_test.go

@@ -235,7 +235,7 @@ func TestGetIPsWithFilter(t *testing.T) {
 	defer srv.Close()
 
 	c := NewClient(srv.URL, "token", 0)
-	ips, err := c.GetIPsWithFilter(context.Background(), "device_id=1&interface_name=mgmt0")
+	ips, err := c.GetIPsWithFilter(context.Background(), "device_id=1&interface=mgmt0")
 	if err != nil {
 		t.Fatalf("GetIPsWithFilter: %v", err)
 	}

internal/netbox/cluster_test.go

@@ -0,0 +1,51 @@
+package netbox
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestSearchAllByCluster(t *testing.T) {
+	var deviceQuery, vmQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		switch r.URL.Path {
+		case "/api/virtualization/clusters/":
+			if r.URL.Query().Get("name__ie") == "PVE" {
+				fmt.Fprint(w, `{"count":2,"results":[{"id":3,"name":"pve"},{"id":4,"name":"pve"}]}`)
+				return
+			}
+			fmt.Fprint(w, `{"count":0,"results":[]}`)
+		case "/api/dcim/devices/":
+			deviceQuery = r.URL.RawQuery
+			fmt.Fprint(w, `{"count":1,"results":[{"id":1,"name":"node1","cluster":{"id":3,"name":"pve"}}]}`)
+		case "/api/virtualization/virtual-machines/":
+			vmQuery = r.URL.RawQuery
+			fmt.Fprint(w, `{"count":1,"results":[{"id":2,"name":"vm1","cluster":{"id":4,"name":"pve"}}]}`)
+		}
+	}))
+	defer srv.Close()
+	c := NewClient(srv.URL, "t", 1)
+
+	hosts, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "PVE", Kind: "device"})
+	if err != nil || len(hosts) != 1 || hosts[0].Name != "node1" || hosts[0].Cluster != "pve" {
+		t.Fatalf("got %+v %v", hosts, err)
+	}
+	if want := "name__ic=&limit=50&offset=0&cluster_id=3&cluster_id=4"; deviceQuery != want {
+		t.Errorf("device query %q, want %q", deviceQuery, want)
+	}
+	if vmQuery != "" {
+		t.Error("VMs queried for kind device")
+	}
+	all, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "PVE"})
+	if err != nil || len(all) != 2 {
+		t.Fatalf("all kinds: %+v %v", all, err)
+	}
+	none, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "missing"})
+	if err != nil || len(none) != 0 {
+		t.Fatalf("unknown cluster: %+v %v", none, err)
+	}
+}

internal/netbox/models.go

@@ -7,6 +7,8 @@ import "strings"
 type SearchOptions struct {
 	Tag  string // filter by tag slug; empty = no filter
 	Kind string // "device" | "vm" | "" (both)
+	// Cluster filters SearchAll by virtualization cluster name (case-insensitive).
+	Cluster string
 }
 
 // HostEntry is a unified model for both devices and virtual machines from NetBox.
@@ -18,6 +20,13 @@ type HostEntry struct {
 	PrimaryIP4 string // e.g. "10.0.1.5" (prefix length stripped)
 	PrimaryIP6 string
 	Tags       []string
+	Cluster    string // virtualization cluster name, if assigned
+}
+
+// netboxCluster is the nested cluster of a device or virtual machine.
+type netboxCluster struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
 }
 
 // netboxIP represents an IP address as returned by the NetBox API.
@@ -34,6 +43,7 @@ type netboxDevice struct {
 	} `json:"tags"`
 	PrimaryIP4 *netboxIP      `json:"primary_ip4"`
 	PrimaryIP6 *netboxIP      `json:"primary_ip6"`
+	Cluster    *netboxCluster `json:"cluster"`
 }
 
 // netboxVM matches the relevant fields of the NetBox /virtualization/virtual-machines/ response.
@@ -45,6 +55,7 @@ type netboxVM struct {
 	} `json:"tags"`
 	PrimaryIP4 *netboxIP      `json:"primary_ip4"`
 	PrimaryIP6 *netboxIP      `json:"primary_ip6"`
+	Cluster    *netboxCluster `json:"cluster"`
 }
 
 type netboxListResponse[T any] struct {

internal/netbox/sources_test.go

@@ -78,7 +78,7 @@ func TestMultiSourceSearchAndRouting(t *testing.T) {
 			if err != nil || len(ips) != 1 || ips[0] != tc.ip {
 				t.Fatalf("wrong IP source: %v, %v", ips, err)
 			}
-			ips, err = c.GetIPsWithFilterForHost(ctx, host, "device_id=1&interface_name=mgmt0")
+			ips, err = c.GetIPsWithFilterForHost(ctx, host, "device_id=1&interface=mgmt0")
 			if err != nil || len(ips) != 1 || ips[0] != tc.ip {
 				t.Fatalf("wrong interface source: %v, %v", ips, err)
 			}

internal/resolver/chain.go

@@ -46,6 +46,8 @@ func newStrategy(name string, cfg config.ResolverConfig) (Strategy, error) {
 			return nil, err
 		}
 		return s, nil
+	case "hostname":
+		return &HostnameStrategy{domain: cfg.HostnameDomain}, nil
 	case "interface_name":
 		if cfg.InterfaceName == "" {
 			return nil, fmt.Errorf("interface_name strategy requires resolver.interface_name to be set")

internal/resolver/hostname.go

@@ -0,0 +1,31 @@
+package resolver
+
+import (
+	"context"
+	"regexp"
+	"strings"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
+)
+
+var validHostname = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*$`)
+
+// HostnameStrategy connects by the NetBox name instead of an IP, so DNS or
+// ~/.ssh/config resolves it. Names without a dot get the optional domain.
+// Names that are no valid hostname fall through to the next strategy.
+type HostnameStrategy struct {
+	domain string
+}
+
+func (s *HostnameStrategy) Name() string { return "hostname" }
+
+func (s *HostnameStrategy) Resolve(_ context.Context, entry *netbox.HostEntry, _ *netbox.Client) (string, error) {
+	name := strings.ToLower(entry.Name)
+	if domain := strings.Trim(s.domain, "."); domain != "" && !strings.Contains(name, ".") {
+		name += "." + strings.ToLower(domain)
+	}
+	if !validHostname.MatchString(name) {
+		return "", ErrNoIP
+	}
+	return name, nil
+}

internal/resolver/hostname_test.go

@@ -0,0 +1,43 @@
+package resolver
+
+import (
+	"context"
+	"testing"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
+)
+
+func TestHostnameStrategy(t *testing.T) {
+	for _, tc := range []struct {
+		name, domain, want string
+	}{
+		{"Web01.Example.com", "", "web01.example.com"},
+		{"web01", "example.com", "web01.example.com"},
+		{"web01", ".example.com.", "web01.example.com"},
+		{"web01.lab", "example.com", "web01.lab"}, // already qualified
+	} {
+		got, err := (&HostnameStrategy{domain: tc.domain}).Resolve(context.Background(), &netbox.HostEntry{Name: tc.name}, nil)
+		if err != nil || got != tc.want {
+			t.Errorf("%q + %q: got %q, %v; want %q", tc.name, tc.domain, got, err, tc.want)
+		}
+	}
+	for _, name := range []string{"Core Switch 1", "-x", "a..b", "web_01"} {
+		if _, err := (&HostnameStrategy{}).Resolve(context.Background(), &netbox.HostEntry{Name: name}, nil); err != ErrNoIP {
+			t.Errorf("%q: got %v, want ErrNoIP", name, err)
+		}
+	}
+}
+
+func TestHostnameAsFallback(t *testing.T) {
+	chain, err := New(config.ResolverConfig{Strategies: []string{"primary_ip", "hostname"}, HostnameDomain: "example.com"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ip, _ := chain.Resolve(context.Background(), &netbox.HostEntry{Name: "web01", PrimaryIP4: "192.0.2.1"}, nil); ip != "192.0.2.1" {
+		t.Fatalf("primary IP first: %q", ip)
+	}
+	if ip, _ := chain.Resolve(context.Background(), &netbox.HostEntry{Name: "web02"}, nil); ip != "web02.example.com" {
+		t.Fatalf("hostname fallback: %q", ip)
+	}
+}

internal/resolver/interface_name.go

@@ -16,13 +16,16 @@ type InterfaceNameStrategy struct {
 func (s *InterfaceNameStrategy) Name() string { return "interface_name" }
 
 func (s *InterfaceNameStrategy) Resolve(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, error) {
-	// Build filter parameters for IP addresses attached to the named interface.
+	// NetBox filters IP addresses by interface name with interface= (devices)
+	// and vminterface= (VMs); unknown parameters would be ignored silently and
+	// return every address of the host. A missing interface is an HTTP 400,
+	// which lets the chain try the next strategy.
 	var filterParam string
 	switch entry.Kind {
 	case "device":
-		filterParam = fmt.Sprintf("device_id=%d&interface_name=%s", entry.ID, url.QueryEscape(s.name))
+		filterParam = fmt.Sprintf("device_id=%d&interface=%s", entry.ID, url.QueryEscape(s.name))
 	case "vm":
-		filterParam = fmt.Sprintf("virtual_machine_id=%d&vminterface_name=%s", entry.ID, url.QueryEscape(s.name))
+		filterParam = fmt.Sprintf("virtual_machine_id=%d&vminterface=%s", entry.ID, url.QueryEscape(s.name))
 	default:
 		return "", fmt.Errorf("unknown kind %q", entry.Kind)
 	}

internal/resolver/interface_name_test.go

@@ -0,0 +1,56 @@
+package resolver
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
+)
+
+// NetBox ignores unknown filters, so the strategy must use the real filter
+// names; otherwise it silently returns the host's first address.
+func TestInterfaceNameStrategyFilters(t *testing.T) {
+	for kind, want := range map[string]string{
+		"device": "device_id=7&interface=mgmt0",
+		"vm":     "virtual_machine_id=7&vminterface=mgmt0",
+	} {
+		var got string
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			q := r.URL.Query()
+			q.Del("limit")
+			q.Del("offset")
+			got = q.Encode()
+			w.Header().Set("Content-Type", "application/json")
+			w.Write([]byte(`{"count":1,"results":[{"address":"10.0.0.7/24"}]}`))
+		}))
+		ip, err := (&InterfaceNameStrategy{name: "mgmt0"}).Resolve(context.Background(), &netbox.HostEntry{ID: 7, Kind: kind}, netbox.NewClient(srv.URL, "t", 1))
+		srv.Close()
+		if err != nil || ip != "10.0.0.7" {
+			t.Fatalf("%s: %q %v", kind, ip, err)
+		}
+		if parsed, _ := urlQuery(want); got != parsed {
+			t.Errorf("%s: query %q, want %q", kind, got, parsed)
+		}
+	}
+}
+
+func TestInterfaceNameStrategyMissingInterfaceFallsThrough(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, `{"vminterface":["Select a valid choice."]}`, http.StatusBadRequest)
+	}))
+	defer srv.Close()
+	client := netbox.NewClient(srv.URL, "t", 1)
+	chain := &Chain{strategies: []Strategy{&InterfaceNameStrategy{name: "mgmt0"}, &PrimaryIPStrategy{}}}
+	ip, err := chain.Resolve(context.Background(), &netbox.HostEntry{ID: 7, Kind: "vm", PrimaryIP4: "10.0.0.9"}, client)
+	if err != nil || ip != "10.0.0.9" {
+		t.Fatalf("got %q %v", ip, err)
+	}
+}
+
+func urlQuery(s string) (string, error) {
+	q, err := url.ParseQuery(s)
+	return q.Encode(), err
+}

internal/setup/hosts.go

@@ -0,0 +1,140 @@
+package setup
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"charm.land/huh/v2"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+)
+
+// configureHosts edits a copy of the static hosts; the caller decides whether to keep it.
+func configureHosts(hosts []config.StaticHost) ([]config.StaticHost, error) {
+	hosts = append([]config.StaticHost(nil), hosts...)
+	for {
+		action := "done"
+		var options []huh.Option[string]
+		for i, host := range hosts {
+			index := strconv.Itoa(i)
+			options = append(options,
+				huh.NewOption("Edit "+host.Name+" ("+host.Address+")", "edit:"+index),
+				huh.NewOption("SSH options for "+host.Name, "ssh:"+index),
+				huh.NewOption("Remove "+host.Name, "remove:"+index))
+		}
+		options = append(options, huh.NewOption("Add host", "add"), huh.NewOption("Back", "done"))
+		err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
+			Title("Static hosts").
+			Description("Hosts that are not in NetBox. They are found before NetBox and work offline.").
+			Options(options...).
+			Value(&action))).Run()
+		if err != nil {
+			return nil, err
+		}
+		if action == "done" {
+			return hosts, nil
+		}
+		if action == "add" {
+			host, err := editHost(config.StaticHost{}, hosts, -1)
+			if err != nil {
+				return nil, err
+			}
+			hosts = append(hosts, host)
+			continue
+		}
+		verb, index, _ := strings.Cut(action, ":")
+		i, _ := strconv.Atoi(index)
+		switch verb {
+		case "edit":
+			host, err := editHost(hosts[i], hosts, i)
+			if err != nil {
+				return nil, err
+			}
+			hosts[i] = host
+		case "ssh":
+			options, err := editSSHOptions("SSH options for "+hosts[i].Name, hosts[i].SSH)
+			if err != nil {
+				return nil, err
+			}
+			hosts[i].SSH = options
+		case "remove":
+			remove := false
+			if err := huh.NewConfirm().Title("Remove " + hosts[i].Name + "?").Value(&remove).Run(); err != nil {
+				return nil, err
+			}
+			if remove {
+				hosts = append(hosts[:i], hosts[i+1:]...)
+			}
+		}
+	}
+}
+
+func editHost(host config.StaticHost, hosts []config.StaticHost, index int) (config.StaticHost, error) {
+	name, address, user := host.Name, host.Address, host.User
+	port := ""
+	if host.Port > 0 {
+		port = strconv.Itoa(host.Port)
+	}
+	tags := strings.Join(host.Tags, ", ")
+	candidate := func() config.StaticHost {
+		out := host
+		out.Name = strings.TrimSpace(name)
+		out.Address = strings.TrimSpace(address)
+		out.User = strings.TrimSpace(user)
+		out.Port, _ = strconv.Atoi(strings.TrimSpace(port))
+		out.Tags = splitList(tags)
+		return out
+	}
+	// huh validates the typed value before storing it, so each validator
+	// checks the host with its own field taken from the argument.
+	validate := func(set func(*config.StaticHost, string)) func(string) error {
+		return func(value string) error {
+			h := candidate()
+			set(&h, strings.TrimSpace(value))
+			return validateHostIn(h, hosts, index)
+		}
+	}
+
+	err := huh.NewForm(huh.NewGroup(
+		huh.NewInput().Title("Name").Description("What you type: netssh NAME. Letters, digits, dots, hyphens.").Value(&name).
+			Validate(validate(func(h *config.StaticHost, v string) { h.Name = v })),
+		huh.NewInput().Title("Address").Description("IP address or DNS name to connect to.").Value(&address).
+			Validate(validate(func(h *config.StaticHost, v string) {
+				h.Address = v
+				if v == "" {
+					h.Address = "-" // required: reported as invalid address
+				}
+			})),
+		huh.NewInput().Title("User").Description("Leave empty for ssh.default_user.").Value(&user).
+			Validate(validate(func(h *config.StaticHost, v string) { h.User = v })),
+		huh.NewInput().Title("Port").Description("Leave empty for ssh.default_port or 22.").Value(&port).Validate(func(s string) error {
+			if s = strings.TrimSpace(s); s == "" {
+				return nil
+			}
+			if n, err := strconv.Atoi(s); err != nil || n < 1 || n > 65535 {
+				return fmt.Errorf("must be a port number between 1 and 65535")
+			}
+			return nil
+		}),
+		huh.NewInput().Title("Tags").Description("Comma-separated, for ssh.rules match: {tag: …}.").Value(&tags),
+	).Title("Static host")).Run()
+	if err != nil {
+		return host, err
+	}
+	return candidate(), nil
+}
+
+// validateHostIn checks host as entry index of hosts (-1 for a new host).
+func validateHostIn(host config.StaticHost, hosts []config.StaticHost, index int) error {
+	others := make([]config.StaticHost, 0, len(hosts)+1)
+	for i, other := range hosts {
+		if i != index {
+			others = append(others, other)
+		}
+	}
+	if host.Address == "" {
+		host.Address = "placeholder" // reported once the address field is filled
+	}
+	return (&config.Config{Hosts: append(others, host)}).ValidateHosts()
+}

internal/setup/instances.go

@@ -20,6 +20,18 @@ func configureInstances(cfg *config.Config) ([]config.NetBoxConfig, error) {
 	}
 	for {
 		if len(sources) == 0 {
+			choice := "add"
+			err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
+				Title("NetBox").
+				Description("netssh looks up hosts in NetBox. Without NetBox, only static hosts (configured next) are available.").
+				Options(huh.NewOption("Add a NetBox instance", "add"), huh.NewOption("Continue without NetBox (static hosts only)", "none")).
+				Value(&choice))).Run()
+			if err != nil {
+				return nil, err
+			}
+			if choice == "none" {
+				return nil, nil
+			}
 			source, err := editInstance(config.NetBoxConfig{Name: "default"}, sources, "")
 			if err != nil {
 				return nil, err

internal/setup/multi.go

@@ -0,0 +1,128 @@
+package setup
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"charm.land/huh/v2"
+
+	"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
+)
+
+func editMulti(cfg *config.Config) error {
+	multiplexer := cfg.Multi.Multiplexer
+	if multiplexer == "" {
+		multiplexer = "auto"
+	}
+	perWindow := ""
+	if cfg.Multi.PanesPerWindow > 0 {
+		perWindow = strconv.Itoa(cfg.Multi.PanesPerWindow)
+	}
+	groups := formatGroups(cfg.Groups)
+	syncKey, soloKey := cfg.Multi.SyncKey, cfg.Multi.SoloKey
+	validKey := func(field string) func(string) error {
+		return func(s string) error {
+			candidate := config.Config{Multi: cfg.Multi}
+			if field == "sync" {
+				candidate.Multi.SyncKey = strings.TrimSpace(s)
+			} else {
+				candidate.Multi.SoloKey = strings.TrimSpace(s)
+			}
+			return candidate.ValidateMulti()
+		}
+	}
+	err := huh.NewForm(huh.NewGroup(
+		huh.NewSelect[string]().
+			Title("Multiplexer").
+			Description("netssh multi opens hosts side by side. auto uses the one you are in, else tmux, else zellij.").
+			Options(huh.NewOption("auto", "auto"), huh.NewOption("tmux", "tmux"), huh.NewOption("zellij", "zellij")).
+			Value(&multiplexer),
+		huh.NewInput().
+			Title("Panes per window").
+			Description(fmt.Sprintf("More hosts open in further windows or tabs. Leave empty for %d.", config.DefaultPanesPerWindow)).
+			Value(&perWindow).
+			Validate(func(s string) error {
+				if s = strings.TrimSpace(s); s == "" {
+					return nil
+				}
+				if n, err := strconv.Atoi(s); err != nil || n < 1 || n > 64 {
+					return errors.New("must be a number between 1 and 64")
+				}
+				return nil
+			}),
+		huh.NewInput().
+			Title("tmux key: broadcast to all panes").
+			Description(fmt.Sprintf("Pressed after the tmux prefix. Empty = %s, none = no key.", config.DefaultSyncKey)).
+			Placeholder(config.DefaultSyncKey).
+			Value(&syncKey).
+			Validate(validKey("sync")),
+		huh.NewInput().
+			Title("tmux key: exclude/include this pane").
+			Description(fmt.Sprintf("Pressed after the tmux prefix. Empty = %s, none = no key.", config.DefaultSoloKey)).
+			Placeholder(config.DefaultSoloKey).
+			Value(&soloKey).
+			Validate(validKey("solo")),
+		huh.NewText().
+			Title("Groups").
+			Description("One per line: NAME: host, tag:TAG, cluster:NAME, @other — open with netssh multi @NAME.").
+			Lines(4).
+			Value(&groups).
+			Validate(func(s string) error {
+				_, err := parseGroups(s)
+				return err
+			}),
+	).Title("Multi-session")).Run()
+	if err != nil {
+		return err
+	}
+	cfg.Multi.Multiplexer = multiplexer
+	if multiplexer == "auto" {
+		cfg.Multi.Multiplexer = ""
+	}
+	cfg.Multi.PanesPerWindow, _ = strconv.Atoi(strings.TrimSpace(perWindow))
+	cfg.Multi.SyncKey = strings.TrimSpace(syncKey)
+	cfg.Multi.SoloKey = strings.TrimSpace(soloKey)
+	cfg.Groups, _ = parseGroups(groups)
+	return nil
+}
+
+// parseGroups reads "NAME: sel1, sel2" lines into groups:.
+func parseGroups(s string) (map[string][]string, error) {
+	var out map[string][]string
+	for _, line := range parseLines(s) {
+		name, members, ok := strings.Cut(line, ":")
+		name = strings.ToLower(strings.TrimSpace(name))
+		// "tag:x" alone has no group name before the first colon worth keeping.
+		if !ok || name == "" || name == "tag" || name == "cluster" {
+			return nil, fmt.Errorf("%q: expected NAME: host, tag:TAG, …", line)
+		}
+		var selectors []string
+		for _, field := range strings.FieldsFunc(members, func(r rune) bool { return r == ',' || r == ' ' || r == '\t' }) {
+			selectors = append(selectors, field)
+		}
+		if out == nil {
+			out = make(map[string][]string)
+		}
+		out[name] = append(out[name], selectors...)
+	}
+	if err := (&config.Config{Groups: out}).ValidateMulti(); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func formatGroups(groups map[string][]string) string {
+	names := make([]string, 0, len(groups))
+	for name := range groups {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	lines := make([]string, 0, len(names))
+	for _, name := range names {
+		lines = append(lines, name+": "+strings.Join(groups[name], ", "))
+	}
+	return strings.Join(lines, "\n")
+}

internal/setup/wizard.go

@@ -36,7 +36,7 @@ func RunWizard(cfg *config.Config) error {
 	if err != nil {
 		return err
 	}
-	c := cache.New(loaded.CachePath(), loaded.Cache.TTL)
+	c := cache.New(loaded.CachePath(), loaded.Cache.TTL).WithStatic(loaded.Hosts)
 	if err := c.Load(); err != nil {
 		return fmt.Errorf("updating aliases: %w", err)
 	}
@@ -90,6 +90,8 @@ func runMenu(cfg *config.Config) error {
 				huh.NewOption("SSH defaults — user, port", "defaults"),
 				huh.NewOption("SSH options — jump host, host keys, target, -o, forwards", "ssh"),
 				huh.NewOption(fmt.Sprintf("SSH rules — per tag, instance, kind, name (%d)", len(cfg.SSH.Rules)), "rules"),
+				huh.NewOption(fmt.Sprintf("Static hosts — hosts not in NetBox (%d)", len(cfg.Hosts)), "hosts"),
+				huh.NewOption(fmt.Sprintf("Multi-session — groups, tmux/zellij (%d groups)", len(cfg.Groups)), "multi"),
 				huh.NewOption("Resolver & cache", "resolver"),
 				huh.NewOption("Shortcuts & command alias", "shortcuts"),
 				huh.NewOption("Completion", "completion"),
@@ -109,6 +111,13 @@ func runMenu(cfg *config.Config) error {
 			if rules, err = configureRules(cfg.SSH.Rules, cfg.NetBoxes); err == nil {
 				cfg.SSH.Rules = rules
 			}
+		case "hosts":
+			var hosts []config.StaticHost
+			if hosts, err = configureHosts(cfg.Hosts); err == nil {
+				cfg.Hosts = hosts
+			}
+		case "multi":
+			err = editMulti(cfg)
 		case "resolver":
 			err = editResolverCache(cfg)
 		case "shortcuts":
@@ -163,12 +172,13 @@ func editResolverCache(cfg *config.Config) error {
 	strategiesRaw := strings.Join(cfg.Resolver.Strategies, ", ")
 	subnets := strings.Join(cfg.Resolver.ManagementSubnets, ", ")
 	interfaceName := cfg.Resolver.InterfaceName
+	hostnameDomain := cfg.Resolver.HostnameDomain
 	cacheTTL := strconv.Itoa(cfg.Cache.TTL)
 	cachePath := cfg.Cache.Path
 	err := huh.NewForm(huh.NewGroup(
 		huh.NewInput().
 			Title("Resolver strategies").
-			Description("Comma-separated, in priority order. First match wins.\nAvailable: primary_ip, management_subnet, interface_name").
+			Description("Comma-separated, in priority order. First match wins.\nAvailable: primary_ip, management_subnet, interface_name, hostname").
 			Placeholder("primary_ip, management_subnet").
 			Value(&strategiesRaw).
 			Validate(validateStrategies),
@@ -181,6 +191,10 @@ func editResolverCache(cfg *config.Config) error {
 			Description("Only used when interface_name strategy is active.").
 			Placeholder("eth0").
 			Value(&interfaceName),
+		huh.NewInput().
+			Title("Hostname domain").
+			Description("Only used by the hostname strategy: appended to NetBox names without a dot,\ne.g. example.com turns web01 into web01.example.com.").
+			Value(&hostnameDomain),
 		huh.NewInput().
 			Title("Cache TTL (seconds)").
 			Value(&cacheTTL).
@@ -201,6 +215,7 @@ func editResolverCache(cfg *config.Config) error {
 	cfg.Resolver.Strategies = parseStrategies(strategiesRaw)
 	cfg.Resolver.ManagementSubnets = splitList(subnets)
 	cfg.Resolver.InterfaceName = strings.TrimSpace(interfaceName)
+	cfg.Resolver.HostnameDomain = strings.Trim(strings.TrimSpace(hostnameDomain), ".")
 	cfg.Cache.TTL, _ = strconv.Atoi(cacheTTL)
 	cfg.Cache.Path = strings.TrimSpace(cachePath)
 	return nil
@@ -321,6 +336,7 @@ var knownStrategies = map[string]bool{
 	"primary_ip":        true,
 	"management_subnet": true,
 	"interface_name":    true,
+	"hostname":          true,
 }
 
 func validateStrategies(s string) error {
@@ -329,7 +345,7 @@ func validateStrategies(s string) error {
 	}
 	for _, name := range parseStrategies(s) {
 		if !knownStrategies[name] {
-			return fmt.Errorf("unknown strategy %q — available: primary_ip, management_subnet, interface_name", name)
+			return fmt.Errorf("unknown strategy %q — available: primary_ip, management_subnet, interface_name, hostname", name)
 		}
 	}
 	return nil
@@ -337,6 +353,9 @@ func validateStrategies(s string) error {
 
 func parseStrategies(s string) []string { return splitList(s) }
 
+// Save validates cfg and writes it to the config file, replacing the old file.
+func Save(cfg config.Config) error { return save(cfg) }
+
 func save(cfg config.Config) error {
 	if err := config.ValidateCommandAlias(cfg.Shell.Alias); err != nil {
 		return err
@@ -350,6 +369,12 @@ func save(cfg config.Config) error {
 	if err := cfg.Shortcuts.Validate(); err != nil {
 		return err
 	}
+	if err := cfg.ValidateHosts(); err != nil {
+		return err
+	}
+	if err := cfg.ValidateMulti(); err != nil {
+		return err
+	}
 	path := config.Path()
 	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
 		return fmt.Errorf("creating config dir: %w", err)
@@ -365,7 +390,7 @@ func save(cfg config.Config) error {
 				writeSSHOptions(&b, "      ", source.SSH)
 			}
 		}
-	} else {
+	} else if cfg.NetBox.URL != "" || len(cfg.Hosts) == 0 {
 		b.WriteString("netbox:\n")
 		fmt.Fprintf(&b, "  url: %q\n  token: %q\n  token_version: %d\n", cfg.NetBox.URL, cfg.NetBox.Token, cfg.NetBox.TokenVersion)
 		if !sshOptionsEmpty(cfg.NetBox.SSH) {
@@ -388,6 +413,9 @@ func save(cfg config.Config) error {
 	if cfg.Resolver.InterfaceName != "" {
 		fmt.Fprintf(&b, "  interface_name: %q\n", cfg.Resolver.InterfaceName)
 	}
+	if cfg.Resolver.HostnameDomain != "" {
+		fmt.Fprintf(&b, "  hostname_domain: %q\n", cfg.Resolver.HostnameDomain)
+	}
 
 	b.WriteString("\ncache:\n")
 	fmt.Fprintf(&b, "  ttl: %d\n", cfg.Cache.TTL)
@@ -416,6 +444,59 @@ func save(cfg config.Config) error {
 		}
 	}
 
+	if len(cfg.Hosts) > 0 {
+		b.WriteString("\nhosts:\n")
+		for _, host := range cfg.Hosts {
+			fmt.Fprintf(&b, "  - name: %q\n    address: %q\n", host.Name, host.Address)
+			if host.User != "" {
+				fmt.Fprintf(&b, "    user: %q\n", host.User)
+			}
+			if host.Port > 0 {
+				fmt.Fprintf(&b, "    port: %d\n", host.Port)
+			}
+			if len(host.Tags) > 0 {
+				b.WriteString("    tags:\n")
+				for _, tag := range host.Tags {
+					fmt.Fprintf(&b, "      - %q\n", tag)
+				}
+			}
+			if !sshOptionsEmpty(host.SSH) {
+				b.WriteString("    ssh:\n")
+				writeSSHOptions(&b, "      ", host.SSH)
+			}
+		}
+	}
+
+	if len(cfg.Groups) > 0 {
+		b.WriteString("\ngroups:\n")
+		names := make([]string, 0, len(cfg.Groups))
+		for name := range cfg.Groups {
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		for _, name := range names {
+			quoted := make([]string, 0, len(cfg.Groups[name]))
+			for _, selector := range cfg.Groups[name] {
+				quoted = append(quoted, strconv.Quote(selector))
+			}
+			fmt.Fprintf(&b, "  %s: [%s]\n", name, strings.Join(quoted, ", "))
+		}
+	}
+	if cfg.Multi != (config.MultiConfig{}) {
+		b.WriteString("\nmulti:\n")
+		if cfg.Multi.Multiplexer != "" {
+			fmt.Fprintf(&b, "  multiplexer: %s\n", cfg.Multi.Multiplexer)
+		}
+		if cfg.Multi.PanesPerWindow > 0 {
+			fmt.Fprintf(&b, "  panes_per_window: %d\n", cfg.Multi.PanesPerWindow)
+		}
+		for _, key := range [][2]string{{"sync_key", cfg.Multi.SyncKey}, {"solo_key", cfg.Multi.SoloKey}} {
+			if key[1] != "" {
+				fmt.Fprintf(&b, "  %s: %q\n", key[0], key[1])
+			}
+		}
+	}
+
 	if cfg.Completion.MaxResults > 0 {
 		fmt.Fprintf(&b, "\ncompletion:\n  max_results: %d\n", cfg.Completion.MaxResults)
 	}
@@ -443,7 +524,7 @@ func save(cfg config.Config) error {
 		fmt.Fprintf(&b, "\nshell:\n  alias: %q\n", cfg.Shell.Alias)
 	}
 
-	if err := storage.WriteFile(path, []byte(b.String()), 0o600); err != nil {
+	if err := storage.WriteFile(path, []byte(strings.TrimLeft(b.String(), "\n")), 0o600); err != nil {
 		return fmt.Errorf("writing config: %w", err)
 	}
 

internal/setup/wizard_test.go

@@ -295,6 +295,12 @@ func TestParseStrategies_PreservesOrder(t *testing.T) {
 	}
 }
 
+func TestValidateStrategiesHostname(t *testing.T) {
+	if err := validateStrategies("primary_ip, hostname"); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestValidateStrategies_Valid(t *testing.T) {
 	cases := []string{
 		"primary_ip",
@@ -568,3 +574,80 @@ func TestSaveForwardsRoundtrip(t *testing.T) {
 		t.Fatalf("forwards lost: %+v / %+v / %+v", loaded.SSH.Forwards, loaded.NetBoxes[0].SSH.Forwards, loaded.SSH.Rules)
 	}
 }
+
+func TestSaveStaticHostsRoundtrip(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	t.Setenv("HOME", t.TempDir())
+	hosts := []config.StaticHost{
+		{Name: "router", Address: "192.168.1.1", User: "admin", Port: 2222, Tags: []string{"home"}, SSH: config.SSHOptions{ProxyJump: "none"}},
+		{Name: "nas", Address: "nas.example.org"},
+	}
+	cfg := config.Config{
+		Resolver: config.ResolverConfig{Strategies: []string{"primary_ip", "hostname"}, HostnameDomain: "example.com"},
+		Hosts:    hosts,
+	}
+	if err := save(cfg); err != nil {
+		t.Fatal(err)
+	}
+	data, _ := os.ReadFile(config.Path())
+	if strings.Contains(string(data), "netbox:") {
+		t.Fatalf("static-only config got an empty netbox section:\n%s", data)
+	}
+	loaded, err := config.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(loaded.Hosts, hosts) || loaded.Resolver.HostnameDomain != "example.com" || loaded.HasNetBox() {
+		t.Fatalf("got %+v / %+v", loaded.Hosts, loaded.Resolver)
+	}
+}
+
+func TestValidateHostIn(t *testing.T) {
+	hosts := []config.StaticHost{{Name: "router", Address: "10.0.0.1"}, {Name: "nas", Address: "10.0.0.2"}}
+	if err := validateHostIn(config.StaticHost{Name: "Router", Address: "10.0.0.9"}, hosts, -1); err == nil {
+		t.Fatal("duplicate name accepted")
+	}
+	if err := validateHostIn(config.StaticHost{Name: "router", Address: "10.0.0.9"}, hosts, 0); err != nil {
+		t.Fatalf("editing a host in place rejected: %v", err)
+	}
+	if err := validateHostIn(config.StaticHost{Name: "new"}, hosts, -1); err != nil {
+		t.Fatalf("empty address while typing rejected: %v", err)
+	}
+	if err := validateHostIn(config.StaticHost{Name: "new", Address: "a b"}, hosts, -1); err == nil {
+		t.Fatal("invalid address accepted")
+	}
+}
+
+func TestParseGroupsAndSaveMulti(t *testing.T) {
+	groups, err := parseGroups("K8s: master1, tag:k8s-worker\npve: cluster:pve-fsn1 @k8s\n")
+	want := map[string][]string{"k8s": {"master1", "tag:k8s-worker"}, "pve": {"cluster:pve-fsn1", "@k8s"}}
+	if err != nil || !reflect.DeepEqual(groups, want) {
+		t.Fatalf("got %v %v", groups, err)
+	}
+	if again, _ := parseGroups(formatGroups(groups)); !reflect.DeepEqual(again, want) {
+		t.Fatalf("roundtrip: %v", again)
+	}
+	for _, bad := range []string{"no colon", "tag:x", "bad name: a", "empty:"} {
+		if _, err := parseGroups(bad); err == nil {
+			t.Errorf("%q accepted", bad)
+		}
+	}
+
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	t.Setenv("HOME", t.TempDir())
+	cfg := config.Config{
+		Hosts:  []config.StaticHost{{Name: "a", Address: "10.0.0.1"}},
+		Groups: groups,
+		Multi:  config.MultiConfig{Multiplexer: "zellij", PanesPerWindow: 4},
+	}
+	if err := save(cfg); err != nil {
+		t.Fatal(err)
+	}
+	loaded, err := config.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(loaded.Groups, want) || loaded.Multi != cfg.Multi {
+		t.Fatalf("got %v %+v", loaded.Groups, loaded.Multi)
+	}
+}

internal/shortcuts/shortcuts.go

@@ -59,6 +59,11 @@ func MakeNormalizer(cfg config.ShortcutsConfig) func(string) string {
 // It normalizes the name (strips configured domains, applies rewrites, optionally strips hyphens) then
 // replaces any remaining dots with underscores so the result is a valid identifier.
 func AliasName(name string, cfg config.ShortcutsConfig) string {
-	s := Normalize(name, cfg)
+	// Shorten only the hostname: anchored rewrite rules must not see "instance/".
+	prefix := ""
+	if source, host, ok := strings.Cut(name, "/"); ok {
+		prefix, name = strings.ToLower(source)+"_", host
+	}
+	s := prefix + Normalize(name, cfg)
 	return strings.NewReplacer(".", "_", "/", "_").Replace(s)
 }

internal/shortcuts/shortcuts_test.go

@@ -115,3 +115,13 @@ func TestNormalizeRewritesOrder(t *testing.T) {
 		t.Fatalf("got %q", got)
 	}
 }
+
+func TestAliasNameRewritesInstanceQualifiedHosts(t *testing.T) {
+	cfg := config.ShortcutsConfig{
+		Domains:  []string{".hoster.test"},
+		Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
+	}
+	if got := shortcuts.AliasName("fsn/fsn1-pve1.hoster.test", cfg); got != "fsn_fsnpve1" {
+		t.Fatalf("got %q", got)
+	}
+}

internal/ssh/args.go

@@ -59,7 +59,7 @@ func (c Client) Parse(args []string) *ParsedArgs {
 func (c Client) parsed(args []string, i int) *ParsedArgs {
 	dest, path := args[i], ""
 	if c.paths {
-		if d, p, remote := splitRemote(dest); remote {
+		if d, p, remote := c.splitRemote(dest); remote {
 			dest, path = d, p
 		}
 	}
@@ -88,7 +88,7 @@ func (c Client) replaceHost(args []string, dests []int, newHost string) []string
 			prefix, original = original[:at+1], original[at+1:]
 		}
 		if c.paths {
-			if _, path, remote := splitRemote(original); remote {
+			if _, path, remote := c.splitRemote(original); remote {
 				suffix = ":" + path
 			}
 		}

internal/ssh/client.go

@@ -13,6 +13,18 @@ type Client struct {
 	port    byte          // flag for the port: -p (ssh) or -P (sftp, scp)
 	user    byte          // flag for the login user; 0 when only user@ or -o User work
 	paths   bool          // destinations are host[:path]
+	// instances are the configured NetBox instance names; "inst/host:path"
+	// is remote only for these, so local paths like "dir/file:x" stay local.
+	instances map[string]bool
+}
+
+// WithInstances returns c aware of the NetBox instance prefixes in host:path.
+func (c Client) WithInstances(names []string) Client {
+	c.instances = make(map[string]bool, len(names))
+	for _, name := range names {
+		c.instances[strings.ToLower(name)] = true
+	}
+	return c
 }
 
 var (
@@ -61,7 +73,7 @@ func (c Client) Operands(args []string) ([]Operand, error) {
 		if strings.HasPrefix(arg, "scp://") || strings.HasPrefix(arg, "sftp://") {
 			return nil, fmt.Errorf("%q: use host:path instead of a URI", arg)
 		}
-		dest, path, remote := splitRemote(arg)
+		dest, path, remote := c.splitRemote(arg)
 		if !remote {
 			continue
 		}
@@ -105,9 +117,22 @@ func (c Client) insertionPoint(args []string) int {
 	return len(args)
 }
 
-// splitRemote mirrors scp's colon(): an argument is remote when a ':' comes
+// splitRemote is splitHostPath with netssh's [user@]instance/host:path form.
+func (c Client) splitRemote(arg string) (dest, path string, remote bool) {
+	if head, rest, ok := strings.Cut(arg, "/"); ok {
+		instance := head[strings.LastIndex(head, "@")+1:]
+		if c.instances[strings.ToLower(instance)] {
+			if d, p, r := splitHostPath(rest); r {
+				return head + "/" + d, p, true
+			}
+		}
+	}
+	return splitHostPath(arg)
+}
+
+// splitHostPath mirrors scp's colon(): an argument is remote when a ':' comes
 // before any '/'. A leading "[" starts a bracketed IPv6 address.
-func splitRemote(arg string) (dest, path string, remote bool) {
+func splitHostPath(arg string) (dest, path string, remote bool) {
 	if strings.HasPrefix(arg, "/") || strings.HasPrefix(arg, ".") {
 		return "", "", false
 	}

internal/ssh/client_test.go

@@ -154,3 +154,27 @@ func TestApplyInsertsOptionsBeforeDoubleDash(t *testing.T) {
 		t.Fatalf("got %v, want %v", got, want)
 	}
 }
+
+// Instance-qualified hosts contain "/" before the ":" of host:path; only
+// configured instances make such an argument remote.
+func TestInstanceQualifiedHostPath(t *testing.T) {
+	scp := SCP.WithInstances([]string{"prod"})
+	ops, err := scp.Operands([]string{"a.txt", "ops@prod/web01:/tmp/", "dir/file:x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := []Operand{{Idx: 1, User: "ops", Host: "prod/web01", Path: "/tmp/"}}; !reflect.DeepEqual(ops, want) {
+		t.Fatalf("got %+v", ops)
+	}
+	got := scp.Apply([]string{"a.txt", "ops@prod/web01:/tmp/"}, []int{1}, Host{Name: "web01", IP: "192.0.2.1"}, config.SSHOptions{}, WrapperFlags{}).Args
+	if want := []string{"a.txt", "ops@192.0.2.1:/tmp/"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("apply: %v", got)
+	}
+	sftp := SFTP.WithInstances([]string{"prod"})
+	if p := sftp.Parse([]string{"prod/web01:/var/log"}); p == nil || p.Host != "prod/web01" || p.Path != "/var/log" {
+		t.Fatalf("sftp: %+v", p)
+	}
+	if ops, _ := SCP.Operands([]string{"prod/web01:/tmp/", "."}); len(ops) != 0 {
+		t.Fatalf("unknown instance must stay local: %+v", ops)
+	}
+}

internal/tui/model.go

@@ -27,8 +27,9 @@ type SelectedHost struct {
 	IP       string
 	User     string   // empty = use config default
 	Port     string   // empty = use default port
-	Action   string   // ActionSSH, ActionSFTP, or ActionTunnel
+	Action   string   // ActionSSH, ActionSFTP, ActionTunnel, or ActionMulti
 	Forwards []string // forward names or specs for ActionTunnel
+	Targets  []string // marked hosts for ActionMulti
 }
 
 // Actions the user can start on a host.
@@ -36,6 +37,7 @@ const (
 	ActionSSH    = ""
 	ActionSFTP   = "sftp"
 	ActionTunnel = "tunnel"
+	ActionMulti  = "multi"
 )
 
 // --- bubbletea messages ---
@@ -74,7 +76,8 @@ func (h hostItem) FilterValue() string { return h.name }
 
 // --- compact list delegate ---
 
-type compactDelegate struct{}
+// compactDelegate shares the model's marks so marked hosts show a dot.
+type compactDelegate struct{ marked map[string]bool }
 
 func (d compactDelegate) Height() int                             { return 1 }
 func (d compactDelegate) Spacing() int                            { return 0 }
@@ -84,7 +87,11 @@ func (d compactDelegate) Render(w io.Writer, m list.Model, index int, item list.
 	if !ok {
 		return
 	}
-	line := fmt.Sprintf("  %s  %s", h.name, lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(h.ip))
+	mark := "  "
+	if d.marked[h.key()] {
+		mark = "● "
+	}
+	line := fmt.Sprintf("  %s%s  %s", mark, h.name, lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(h.ip))
 	if index == m.Index() {
 		line = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("86")).Render("> " + strings.TrimPrefix(line, "  "))
 	}
@@ -173,6 +180,8 @@ type Model struct {
 	filterOpen                     bool            // Ctrl+F toggles
 	editMode                       bool            // Ctrl+E on the selected item
 	forwardMode                    bool            // Ctrl+T on the selected item
+	marked                         map[string]bool // hostItem.key() of hosts marked with space
+	markOrder                      []string        // targets in the order they were marked
 }
 
 func New(client *netbox.Client, c *cache.Cache, defaultUser string, defaultPorts ...int) *Model {
@@ -191,7 +200,8 @@ func New(client *netbox.Client, c *cache.Cache, defaultUser string, defaultPorts
 	fwd.Prompt = ""
 	fwd.Placeholder = "web, 8080:localhost:80"
 
-	l := list.New(nil, compactDelegate{}, 0, 0)
+	marked := make(map[string]bool)
+	l := list.New(nil, compactDelegate{marked: marked}, 0, 0)
 	l.SetShowHelp(false)
 	l.SetShowTitle(false)
 	l.SetShowStatusBar(false)
@@ -212,6 +222,7 @@ func New(client *netbox.Client, c *cache.Cache, defaultUser string, defaultPorts
 		filterInput:  fi,
 		editInput:    ei,
 		forwardInput: fwd,
+		marked:       marked,
 		list:         l,
 		client:       client,
 		cache:        c,
@@ -386,11 +397,26 @@ func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 
 		case "enter":
+			if len(m.markOrder) > 0 {
+				m.selected = &SelectedHost{Action: ActionMulti, Targets: append([]string(nil), m.markOrder...)}
+				return m, tea.Quit
+			}
 			if item, ok := m.list.SelectedItem().(hostItem); ok {
 				m.selected = &SelectedHost{Name: item.name, IP: item.ip, Kind: item.kind}
 				return m, tea.Quit
 			}
 
+		case "space":
+			if item, ok := m.list.SelectedItem().(hostItem); ok {
+				m.toggleMark(item)
+				m.list.CursorDown()
+				return m, nil
+			}
+
+		case "ctrl+a":
+			m.toggleAllVisible()
+			return m, nil
+
 		case "ctrl+e":
 			if item, ok := m.list.SelectedItem().(hostItem); ok {
 				m.openEdit(item)
@@ -584,7 +610,10 @@ func (m *Model) viewContent() string {
 		sb.WriteString(m.editInput.View() + "\n")
 		sb.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render("  enter connect  esc cancel") + "\n")
 	} else {
-		hint := "ctrl+c quit  enter connect  ctrl+o sftp  ctrl+t forward  ctrl+e edit  ctrl+f filter  ctrl+n notes  ctrl+b NetBox"
+		hint := "ctrl+c quit  enter connect  space mark  ctrl+o sftp  ctrl+t forward  ctrl+e edit  ctrl+f filter  ctrl+n notes  ctrl+b NetBox"
+		if n := len(m.markOrder); n > 0 {
+			hint = fmt.Sprintf("%d marked — enter open side by side  space unmark  ctrl+a all  esc quit", n)
+		}
 		sb.WriteString("\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(hint) + "\n")
 	}
 
@@ -724,6 +753,42 @@ func (m *Model) buildSelected(item hostItem) *SelectedHost {
 
 func (m *Model) SetNotes(service *notes.Service) { m.noteService = service }
 
+func (h hostItem) key() string { return h.name + "\x00" + h.kind }
+
+// toggleMark marks or unmarks a host for opening several side by side.
+func (m *Model) toggleMark(item hostItem) {
+	key := item.key()
+	if m.marked[key] {
+		delete(m.marked, key)
+		for i, target := range m.markOrder {
+			if target == item.name {
+				m.markOrder = append(m.markOrder[:i], m.markOrder[i+1:]...)
+				break
+			}
+		}
+		return
+	}
+	m.marked[key] = true
+	m.markOrder = append(m.markOrder, item.name)
+}
+
+// toggleAllVisible marks every listed host, or unmarks them if all are marked.
+func (m *Model) toggleAllVisible() {
+	var items []hostItem
+	allMarked := true
+	for _, it := range m.list.Items() {
+		if item, ok := it.(hostItem); ok {
+			items = append(items, item)
+			allMarked = allMarked && m.marked[item.key()]
+		}
+	}
+	for _, item := range items {
+		if m.marked[item.key()] == allMarked {
+			m.toggleMark(item)
+		}
+	}
+}
+
 // SetForwards provides the forward names configured for a host (ctrl+t).
 func (m *Model) SetForwards(forwardsFor func(name, kind string, tags []string) []string) {
 	m.forwardsFor = forwardsFor

internal/tui/model_test.go

@@ -122,3 +122,38 @@ func TestForwardInputEscCancels(t *testing.T) {
 		t.Fatal("esc did not cancel")
 	}
 }
+
+func TestSpaceMarksHostsAndEnterOpensThem(t *testing.T) {
+	m := New(nil, nil, "")
+	m.updateListItems([]netbox.HostEntry{{Name: "a", Kind: "device"}, {Name: "b", Kind: "device"}, {Name: "c", Kind: "vm"}})
+	m.Update(tea.KeyPressMsg{Code: tea.KeySpace, Text: " "})
+	if len(m.markOrder) != 1 || m.markOrder[0] != "a" || m.list.Index() != 1 {
+		t.Fatalf("space: marks %v, cursor %d", m.markOrder, m.list.Index())
+	}
+	if m.input.Value() != "" {
+		t.Fatal("space went into the search field")
+	}
+	m.list.Select(2)
+	m.Update(tea.KeyPressMsg{Code: tea.KeySpace, Text: " "})
+	if !strings.Contains(m.viewContent(), "2 marked") {
+		t.Fatalf("no marked count:\n%s", m.viewContent())
+	}
+	m.Update(tea.KeyPressMsg{Code: tea.KeyEnter})
+	if m.selected == nil || m.selected.Action != ActionMulti || !reflect.DeepEqual(m.selected.Targets, []string{"a", "c"}) {
+		t.Fatalf("got %+v", m.selected)
+	}
+}
+
+func TestCtrlATogglesAllVisible(t *testing.T) {
+	m := New(nil, nil, "")
+	m.updateListItems([]netbox.HostEntry{{Name: "a"}, {Name: "b"}})
+	m.toggleMark(hostItem{name: "a"})
+	m.Update(tea.KeyPressMsg{Code: 'a', Mod: tea.ModCtrl})
+	if !reflect.DeepEqual(m.markOrder, []string{"a", "b"}) {
+		t.Fatalf("mark all: %v", m.markOrder)
+	}
+	m.Update(tea.KeyPressMsg{Code: 'a', Mod: tea.ModCtrl})
+	if len(m.markOrder) != 0 {
+		t.Fatalf("unmark all: %v", m.markOrder)
+	}
+}

renovate.json

@@ -25,6 +25,19 @@
       ],
       "enabled": true
     },
+    {
+      "description": "Skip major updates of indirect Go modules: a new major version is a separate module path that no dependency imports, so the update only adds an unused requirement",
+      "matchManagers": [
+        "gomod"
+      ],
+      "matchDepTypes": [
+        "indirect"
+      ],
+      "matchUpdateTypes": [
+        "major"
+      ],
+      "enabled": false
+    },
     {
       "description": "Update the Go version declared in go.mod",
       "matchManagers": [

testenv/README.md

@@ -0,0 +1,116 @@
+# netssh test environment
+
+A local Docker environment for testing every netssh feature against real
+services: two NetBox instances, SSH targets on three networks, a jump host,
+and a client with ssh, sftp, scp, tmux, zellij, bash, zsh, and fish. It is for
+local use only and is not part of CI/CD.
+
+```sh
+testenv/up.sh            # build, start, seed NetBox (first start ~6 min, then ~1 min)
+testenv/test.sh          # run all tests; testenv/test.sh tunnel runs only matching files
+testenv/shell.sh         # interactive shell in the client, netssh configured
+testenv/down.sh          # stop and delete everything (volumes, generated state)
+```
+
+`test.sh` rebuilds the client image first, so the tests always run the current
+source. `NO_BUILD=1 testenv/test.sh` skips that. Exit code 1 if any check fails.
+
+Requirements: Docker with Compose v2, about 3 GB RAM, ports 18000/18001 on
+127.0.0.1 free.
+
+## Topology
+
+```
+public 10.231.0.0/24 + fd00:30::/64   mgmt 10.231.1.0/24           prod 10.231.2.0/24
+ client .10 ────────────┬─ bastion .30 ───────────────────────────────┬─ (only via bastion)
+ netbox-fsn .20         │                 fsn1-pve1..3 .11-.13 (mgmt0) │  fsn1-pve1..3 .11-.13 (eth0)
+ netbox-lab .21         │                 lab-db1 .41, lab-web1 .42    │  web1 .21, web2 .22
+ legacy-box .50         client .10 ───────┘
+ v6-host fd00:30::60
+```
+
+| NetBox | Host | Kind | Primary IP | Other | Tags |
+|---|---|---|---|---|---|
+| fsn | `fsn1-pve1..3.hoster.test` | device, cluster `pve-fsn1` | eth0 = prod (needs bastion) | mgmt0 = mgmt (direct) | `pve` |
+| fsn | `bastion.hoster.test` | device | 10.231.0.30 | | `bastion` |
+| fsn | `v6-host` | device | fd00:30::60 (IPv6 only) | | `ipv6` |
+| fsn | `web1`, `web2` | VM, cluster `pve-fsn1` | prod (needs bastion) | | `web` |
+| lab | `lab-db1` | device | 10.231.1.41 | | `db` |
+| lab | `web1` | VM, cluster `lab-k8s` | 10.231.1.42 | | `web` |
+| — | `legacy-box` (10.231.0.50) | static host | | | |
+
+- **fsn** uses a v2 token (`nbt_…`), **lab** a legacy v1 token; both come from `.state/env`.
+- `web1` exists in both instances (ambiguity, `instance/host`).
+- Docker DNS resolves the `*.hoster.test` names on the mgmt network (`hostname` strategy).
+- Every target runs sshd on ports 22 and 2222 with users `ops` and `admin`, and an HTTP server on its own 127.0.0.1:8081 for tunnel tests ("hello from HOST").
+- NetBox UI: http://127.0.0.1:18000 (fsn), http://127.0.0.1:18001 (lab), login `admin` / `admin`.
+
+## Files
+
+| Path | Purpose |
+|---|---|
+| `compose.yaml` | All services and networks. |
+| `client.Dockerfile`, `client-entrypoint.sh` | Client image; builds netssh from the repository. |
+| `targets/` | SSH target image (sshd config, entrypoint). |
+| `seed/seed.py` | Fills both NetBox instances via the REST API (idempotent), writes `.state/`. |
+| `tests/run.sh`, `tests/lib.sh` | Test runner and helpers (`check`, `expect_out`, `expect_eq`, `expect_fail`, `wait_for`). |
+| `tests/NN-*.sh` | Test files; each runs in a fresh `HOME`. |
+| `tests/drive.py` | Drives `netssh configure` in huh's accessible mode. |
+| `.keys/`, `.state/` | Generated test key and seed output (git-ignored). |
+| `.artifacts/` | Screenshots from `tests/16-render.sh` (git-ignored). |
+
+## Writing tests
+
+Each `tests/NN-name.sh` is sourced by `run.sh` in a subshell with a new
+`HOME`, `XDG_CONFIG_HOME`, and `XDG_CACHE_HOME`. Write the netssh config with
+`config <<'EOF' … EOF` (both NetBox instances plus your YAML) or `config_only`
+(no NetBox), then use the helpers:
+
+```sh
+config <<'EOF'
+ssh: {default_user: ops}
+EOF
+expect_eq   "connect"   "fsn1-pve1" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_out  "dry run"   "-J ops@10.231.0.30" netssh --dry-run fsn/web1
+expect_fail "ambiguous" "found 2 exact matches" netssh web1
+```
+
+ssh always reads `/home/tester/.ssh/config` (OpenSSH ignores `$HOME`): it uses
+the test key, `BatchMode`, `StrictHostKeyChecking accept-new`, and
+`LogLevel ERROR`. Tests that need their own known_hosts set
+`ssh.options.UserKnownHostsFile`. The TUI test runs netssh inside tmux and
+reads the screen with `tmux capture-pane`. The multi test (`15-multi.sh`)
+opens panes in real tmux and zellij sessions and checks that broadcast typing
+reaches every node.
+
+## What a user sees: `16-render.sh`
+
+The render test runs tmux, zellij, and the TUI in a real terminal emulator —
+xterm on a virtual X server (Xvfb) — takes screenshots, and reads them back
+with OCR (tesseract). It checks what is actually drawn: remote prompts in all
+panes, borders and titles with the host names, `[SYNC]` appearing and
+disappearing, panes side by side, broadcast output in every pane, input in one
+pane only without broadcast, the status bar, and the TUI marks. The broadcast
+keys are pressed as a user would: `tmux send-keys -K` delivers them to the
+xterm client, so they pass through the prefix and key tables (`prefix e` →
+`[SOLO]` and the pane drops out of the broadcast; `prefix S` toggles all panes;
+other windows stay unaffected).
+
+```sh
+testenv/test.sh render          # then look at the screenshots:
+ls testenv/.artifacts/          # tmux-1.png, zellij-2.png, tui-3.png, …
+```
+
+Helpers in `lib.sh`: `start_screen`/`stop_screen`, `term CMD…` (full-screen
+xterm), `shot NAME`, `screen_shows NAME TEXT…`, `screen_count NAME TEXT`.
+OCR reads each screenshot in three preprocessing variants (plain, stretched for
+dim gray, brightest channel for colored text) and normalizes characters it
+confuses in DejaVu Sans Mono (`1`/`l`, `C`/`(`), so checks stay robust without
+becoming vague.
+
+## Not covered
+
+- The installer (`install.sh`) downloads release assets from Gitea; it is tested by the Go tests with local fixtures.
+- macOS paths and behaviour.
+- `netssh uninstall` runs only with `--dry-run`, so the client keeps its binary.
+- Rendering is checked in xterm with DejaVu Sans Mono. Other terminals and fonts may differ, e.g. zellij's Powerline arrows need a Nerd Font.

testenv/client-entrypoint.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+# ssh reads ~/.ssh from the passwd entry, not $HOME, so the key and ssh config
+# live in /home/tester for every test; tests isolate netssh via HOME/XDG_*.
+set -eu
+mkdir -p /home/tester/.ssh
+if [ -f /keys/id_ed25519 ]; then
+  install -m 600 /keys/id_ed25519 /home/tester/.ssh/id_ed25519
+fi
+cat >/home/tester/.ssh/config <<'EOF'
+Host *
+  IdentityFile ~/.ssh/id_ed25519
+  IdentitiesOnly yes
+  BatchMode yes
+  ConnectTimeout 5
+  StrictHostKeyChecking accept-new
+  LogLevel ERROR
+EOF
+chmod 700 /home/tester/.ssh
+chmod 600 /home/tester/.ssh/config
+exec "$@"

testenv/client.Dockerfile

@@ -0,0 +1,26 @@
+# Client for the netssh test environment: netssh built from this repository
+# plus everything it drives or integrates with (ssh, sftp, scp, tmux, zellij,
+# bash, zsh, fish). Rebuild after code changes: testenv/up.sh or
+# docker compose -f testenv/compose.yaml build client
+FROM golang:1.27.4-alpine3.23 AS build
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
+COPY cmd ./cmd
+COPY internal ./internal
+RUN CGO_ENABLED=0 go build -o /out/netssh ./cmd/netssh
+
+FROM alpine:3.23
+# xvfb/xterm/imagemagick/tesseract: render panes in a real terminal emulator,
+# take screenshots, and read them back with OCR (tests/16-render.sh).
+RUN apk add --no-cache openssh-client-default tmux zellij bash zsh fish bash-completion \
+      curl python3 jq ncurses coreutils grep \
+      xvfb xterm imagemagick tesseract-ocr tesseract-ocr-data-eng font-dejavu \
+ && adduser -D -s /bin/bash tester
+COPY --from=build /out/netssh /usr/local/bin/netssh
+COPY testenv/client-entrypoint.sh /entrypoint.sh
+USER tester
+WORKDIR /home/tester
+ENV TERM=xterm-256color LANG=C.UTF-8
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["sleep", "infinity"]

testenv/compose.yaml

@@ -0,0 +1,211 @@
+# netssh test environment — local only, not used by CI/CD. See testenv/README.md.
+#
+#   public 10.231.0.0/24 + fd00:30::/64   client, NetBox x2, bastion, static host, IPv6 host
+#   mgmt   10.231.1.0/24                  client, Proxmox nodes (mgmt0), lab hosts
+#   prod   10.231.2.0/24                  bastion, Proxmox nodes (eth0), VMs — not reachable from the client
+name: netssh-test
+
+x-netbox: &netbox
+  image: netboxcommunity/netbox:v4.7.4-5.1.1
+  depends_on:
+    postgres: {condition: service_healthy}
+    redis: {condition: service_healthy}
+  healthcheck:
+    test: ["CMD-SHELL", "curl -sf http://localhost:8080/login/ >/dev/null"]
+    interval: 10s
+    timeout: 5s
+    retries: 60
+    start_period: 60s
+
+x-netbox-env: &netbox-env
+  DB_HOST: postgres
+  DB_USER: netbox
+  DB_PASSWORD: netbox
+  REDIS_HOST: redis
+  SECRET_KEY: netssh-test-environment-secret-key-0123456789-abcdefghijklmnopqrstuvwxyz
+  API_TOKEN_PEPPER_1: netssh-test-environment-pepper-0123456789-abcdefghijklmnop
+  SUPERUSER_NAME: admin
+  SUPERUSER_EMAIL: admin@example.com
+  SUPERUSER_PASSWORD: admin
+  SUPERUSER_API_KEY: netsshtest01
+  SUPERUSER_API_TOKEN: 0123456789abcdef0123456789abcdef01234567
+  SKIP_SUPERUSER: "false"
+
+x-target: &target
+  build:
+    context: ..
+    dockerfile: testenv/targets/target.Dockerfile
+  image: netssh-test-target
+  volumes:
+    - ./.keys/authorized_keys:/keys/authorized_keys:ro
+
+services:
+  postgres:
+    image: postgres:18-alpine
+    environment:
+      POSTGRES_USER: netbox
+      POSTGRES_PASSWORD: netbox
+      POSTGRES_DB: netbox
+    volumes:
+      - ./postgres-init.sql:/docker-entrypoint-initdb.d/init.sql:ro
+      - postgres:/var/lib/postgresql
+    networks: [backend]
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U netbox"]
+      interval: 5s
+      retries: 30
+
+  redis:
+    image: redis:8-alpine
+    networks: [backend]
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      retries: 30
+
+  netbox-fsn:
+    <<: *netbox
+    hostname: netbox-fsn
+    environment:
+      <<: *netbox-env
+      DB_NAME: netbox_fsn
+      REDIS_DATABASE: "0"
+      REDIS_CACHE_DATABASE: "1"
+    ports: ["127.0.0.1:18000:8080"]
+    networks:
+      backend: {}
+      public: {ipv4_address: 10.231.0.20}
+
+  netbox-lab:
+    <<: *netbox
+    hostname: netbox-lab
+    environment:
+      <<: *netbox-env
+      DB_NAME: netbox_lab
+      REDIS_DATABASE: "2"
+      REDIS_CACHE_DATABASE: "3"
+    ports: ["127.0.0.1:18001:8080"]
+    networks:
+      backend: {}
+      public: {ipv4_address: 10.231.0.21}
+
+  # Jump host: the only way from the client into the prod network.
+  bastion:
+    <<: *target
+    hostname: bastion
+    networks:
+      public: {ipv4_address: 10.231.0.30, aliases: [bastion.hoster.test]}
+      prod: {ipv4_address: 10.231.2.30}
+
+  fsn1-pve1:
+    <<: *target
+    hostname: fsn1-pve1
+    networks:
+      mgmt: {ipv4_address: 10.231.1.11, aliases: [fsn1-pve1.hoster.test]}
+      prod: {ipv4_address: 10.231.2.11}
+  fsn1-pve2:
+    <<: *target
+    hostname: fsn1-pve2
+    networks:
+      mgmt: {ipv4_address: 10.231.1.12, aliases: [fsn1-pve2.hoster.test]}
+      prod: {ipv4_address: 10.231.2.12}
+  fsn1-pve3:
+    <<: *target
+    hostname: fsn1-pve3
+    networks:
+      mgmt: {ipv4_address: 10.231.1.13, aliases: [fsn1-pve3.hoster.test]}
+      prod: {ipv4_address: 10.231.2.13}
+
+  # VMs of cluster pve-fsn1: only in prod, so they need the bastion.
+  web1:
+    <<: *target
+    hostname: web1
+    networks:
+      prod: {ipv4_address: 10.231.2.21}
+  web2:
+    <<: *target
+    hostname: web2
+    networks:
+      prod: {ipv4_address: 10.231.2.22}
+
+  # NetBox instance "lab": a device and a VM named web1 like the fsn VM.
+  lab-db1:
+    <<: *target
+    hostname: lab-db1
+    networks:
+      mgmt: {ipv4_address: 10.231.1.41}
+  lab-web1:
+    <<: *target
+    hostname: lab-web1
+    networks:
+      mgmt: {ipv4_address: 10.231.1.42}
+
+  # Not in NetBox: tested as a static host.
+  legacy-box:
+    <<: *target
+    hostname: legacy-box
+    networks:
+      public: {ipv4_address: 10.231.0.50}
+
+  # In NetBox with an IPv6 primary address only.
+  v6-host:
+    <<: *target
+    hostname: v6-host
+    networks:
+      public: {ipv4_address: 10.231.0.60, ipv6_address: "fd00:30::60"}
+
+  client:
+    build:
+      context: ..
+      dockerfile: testenv/client.Dockerfile
+    image: netssh-test-client
+    hostname: client
+    init: true
+    volumes:
+      - ./.keys:/keys:ro
+      - ./.state:/state
+      - ./tests:/tests:ro
+      - ./.artifacts:/artifacts
+    networks:
+      public: {ipv4_address: 10.231.0.10, ipv6_address: "fd00:30::10"}
+      mgmt: {ipv4_address: 10.231.1.10}
+
+  # Fills both NetBox instances and writes /state/netssh.yaml, then exits.
+  seed:
+    image: netssh-test-client
+    depends_on:
+      client: {condition: service_started}
+      netbox-fsn: {condition: service_healthy}
+      netbox-lab: {condition: service_healthy}
+    volumes:
+      - ./.state:/state
+      - ./seed:/seed:ro
+    networks:
+      public: {}
+    command: ["python3", "/seed/seed.py"]
+    restart: "no"
+
+# Fixed subnets outside Docker's default address pools (172.17-31.x, 192.168.x),
+# so automatically numbered networks of other projects cannot collide.
+networks:
+  backend:
+    ipam:
+      config:
+        - subnet: 10.231.3.0/24
+  public:
+    enable_ipv6: true
+    ipam:
+      config:
+        - subnet: 10.231.0.0/24
+        - subnet: fd00:30::/64
+  mgmt:
+    ipam:
+      config:
+        - subnet: 10.231.1.0/24
+  prod:
+    ipam:
+      config:
+        - subnet: 10.231.2.0/24
+
+volumes:
+  postgres: {}

testenv/down.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Stop the netssh test environment and remove its volumes and state.
+set -euo pipefail
+cd "$(dirname "$0")"
+docker compose -f compose.yaml down -v --remove-orphans
+rm -rf .state

testenv/postgres-init.sql

@@ -0,0 +1,3 @@
+-- One Postgres serves both NetBox instances of the test environment.
+CREATE DATABASE netbox_fsn OWNER netbox;
+CREATE DATABASE netbox_lab OWNER netbox;

testenv/seed/seed.py

@@ -0,0 +1,171 @@
+"""Fill both NetBox instances of the netssh test environment.
+
+Idempotent: objects are looked up before they are created, so running the
+seed again leaves NetBox unchanged. Writes /state/env (tokens) and
+/state/netssh.yaml (base config for the tests).
+"""
+
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+
+FSN = "http://10.231.0.20:8080"
+LAB = "http://10.231.0.21:8080"
+# Superuser v2 token from compose.yaml (SUPERUSER_API_KEY / SUPERUSER_API_TOKEN).
+V2_TOKEN = "nbt_netsshtest01.0123456789abcdef0123456789abcdef01234567"
+STATE = "/state"
+
+
+class NetBox:
+    def __init__(self, url):
+        self.url = url
+
+    def call(self, method, path, body=None):
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(self.url + "/api/" + path, data=data, method=method)
+        req.add_header("Authorization", "Bearer " + V2_TOKEN)
+        req.add_header("Content-Type", "application/json")
+        req.add_header("Accept", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                raw = resp.read()
+                return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as err:
+            sys.exit(f"{method} {path}: HTTP {err.code}: {err.read().decode(errors='replace')}")
+
+    def find(self, path, **filters):
+        query = "&".join(f"{k}={urllib.request.quote(str(v))}" for k, v in filters.items())
+        results = self.call("GET", f"{path}?{query}&limit=2")["results"]
+        return results[0] if results else None
+
+    def ensure(self, path, lookup, body):
+        """Return the object matching lookup, creating it from body if missing."""
+        found = self.find(path, **lookup)
+        if found:
+            return found
+        return self.call("POST", path, body)
+
+    def wait(self):
+        for _ in range(120):
+            try:
+                self.call("GET", "status/")
+                return
+            except SystemExit:
+                pass
+            except (urllib.error.URLError, ConnectionError, TimeoutError):
+                pass
+            time.sleep(5)
+        sys.exit(f"NetBox {self.url} did not become ready")
+
+
+def base(nb, site, cluster_type, cluster):
+    for tag in ("pve", "web", "bastion", "db", "ipv6"):
+        nb.ensure("extras/tags/", {"slug": tag}, {"name": tag, "slug": tag})
+    site = nb.ensure("dcim/sites/", {"slug": site}, {"name": site, "slug": site, "status": "active"})
+    mfr = nb.ensure("dcim/manufacturers/", {"slug": "generic"}, {"name": "Generic", "slug": "generic"})
+    role = nb.ensure("dcim/device-roles/", {"slug": "server"}, {"name": "Server", "slug": "server", "color": "2196f3"})
+    dtype = nb.ensure("dcim/device-types/", {"slug": "generic-server"},
+                      {"manufacturer": mfr["id"], "model": "Generic Server", "slug": "generic-server"})
+    ctype = nb.ensure("virtualization/cluster-types/", {"slug": cluster_type},
+                      {"name": cluster_type, "slug": cluster_type})
+    cluster = nb.ensure("virtualization/clusters/", {"name": cluster},
+                        {"name": cluster, "type": ctype["id"], "status": "active"})
+    return {"site": site["id"], "role": role["id"], "type": dtype["id"], "cluster": cluster["id"]}
+
+
+def device(nb, ids, name, ips, tags=(), cluster=False, comments=""):
+    """ips: list of (interface, address, primary) with primary in (None, 4, 6)."""
+    body = {"name": name, "role": ids["role"], "device_type": ids["type"], "site": ids["site"],
+            "status": "active", "tags": [{"slug": t} for t in tags], "comments": comments}
+    if cluster:
+        body["cluster"] = ids["cluster"]
+    dev = nb.ensure("dcim/devices/", {"name": name}, body)
+    primary = {}
+    for ifname, address, family in ips:
+        iface = nb.ensure("dcim/interfaces/", {"device_id": dev["id"], "name": ifname},
+                          {"device": dev["id"], "name": ifname, "type": "1000base-t"})
+        ip = nb.ensure("ipam/ip-addresses/", {"address": address},
+                       {"address": address, "assigned_object_type": "dcim.interface", "assigned_object_id": iface["id"]})
+        if family:
+            primary[f"primary_ip{family}"] = ip["id"]
+    if primary:
+        nb.call("PATCH", f"dcim/devices/{dev['id']}/", primary)
+
+
+def vm(nb, ids, name, address, tags=()):
+    machine = nb.ensure("virtualization/virtual-machines/", {"name": name},
+                        {"name": name, "cluster": ids["cluster"], "status": "active",
+                         "tags": [{"slug": t} for t in tags]})
+    iface = nb.ensure("virtualization/interfaces/", {"virtual_machine_id": machine["id"], "name": "eth0"},
+                      {"virtual_machine": machine["id"], "name": "eth0"})
+    ip = nb.ensure("ipam/ip-addresses/", {"address": address},
+                   {"address": address, "assigned_object_type": "virtualization.vminterface",
+                    "assigned_object_id": iface["id"]})
+    nb.call("PATCH", f"virtualization/virtual-machines/{machine['id']}/", {"primary_ip4": ip["id"]})
+
+
+def v1_token(nb):
+    """A legacy v1 token for the lab instance, reused from /state/env if present."""
+    env = read_env()
+    if env.get("LAB_TOKEN"):
+        return env["LAB_TOKEN"]
+    user = nb.find("users/users/", username="admin")
+    token = nb.call("POST", "users/tokens/", {"user": user["id"], "version": 1, "description": "netssh v1 test"})
+    plaintext = token.get("token") or token.get("plaintext")
+    if not plaintext:
+        sys.exit(f"v1 token response without plaintext: {token}")
+    return plaintext
+
+
+def read_env():
+    env = {}
+    try:
+        with open(os.path.join(STATE, "env")) as f:
+            for line in f:
+                key, _, value = line.strip().partition("=")
+                env[key] = value
+    except FileNotFoundError:
+        pass
+    return env
+
+
+def main():
+    fsn, lab = NetBox(FSN), NetBox(LAB)
+    fsn.wait()
+    lab.wait()
+
+    ids = base(fsn, "fsn1", "proxmox", "pve-fsn1")
+    for n in (1, 2, 3):
+        device(fsn, ids, f"fsn1-pve{n}.hoster.test",
+               [("eth0", f"10.231.2.1{n}/24", 4), ("mgmt0", f"10.231.1.1{n}/24", None)],
+               tags=("pve",), cluster=True, comments=f"Proxmox node {n}")
+    device(fsn, ids, "bastion.hoster.test", [("eth0", "10.231.0.30/24", 4)], tags=("bastion",))
+    device(fsn, ids, "v6-host", [("eth0", "fd00:30::60/64", 6)], tags=("ipv6",))
+    vm(fsn, ids, "web1", "10.231.2.21/24", tags=("web",))
+    vm(fsn, ids, "web2", "10.231.2.22/24", tags=("web",))
+
+    ids = base(lab, "lab", "kubernetes", "lab-k8s")
+    device(lab, ids, "lab-db1", [("eth0", "10.231.1.41/24", 4)], tags=("db",))
+    vm(lab, ids, "web1", "10.231.1.42/24", tags=("web",))
+
+    lab_token = v1_token(lab)
+    os.makedirs(STATE, exist_ok=True)
+    with open(os.path.join(STATE, "env"), "w") as f:
+        f.write(f"FSN_URL={FSN}\nLAB_URL={LAB}\nFSN_TOKEN={V2_TOKEN}\nLAB_TOKEN={lab_token}\n")
+    with open(os.path.join(STATE, "netssh.yaml"), "w") as f:
+        f.write(f"""netboxes:
+  - name: fsn
+    url: "{FSN}"
+    token: "{V2_TOKEN}"
+  - name: lab
+    url: "{LAB}"
+    token: "{lab_token}"
+""")
+    print("seed: done (fsn: 3 nodes, bastion, v6-host, 2 VMs; lab: lab-db1, web1)")
+
+
+if __name__ == "__main__":
+    main()

testenv/shell.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Interactive shell in the client with a ready netssh config (fresh home).
+set -euo pipefail
+cd "$(dirname "$0")"
+exec docker compose -f compose.yaml exec -it client bash -c '
+  . /tests/lib.sh
+  new_home
+  base_config >"$XDG_CONFIG_HOME/netssh.yaml" <<EOF
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  host_key_checking: accept-new
+  rules:
+    - match: {kind: vm, instance: fsn}
+      proxy_jump: ops@10.231.0.30
+EOF
+  echo "netssh is configured (HOME=$HOME). Try: netssh cache refresh && netssh"
+  exec bash -i'

testenv/targets/entrypoint.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Prepares host keys and the test users, starts a small HTTP server for the
+# tunnel tests (reachable only on the target itself), then runs sshd.
+set -eu
+
+[ -f /etc/ssh/ssh_host_ed25519_key ] || ssh-keygen -q -t ed25519 -N '' -f /etc/ssh/ssh_host_ed25519_key
+
+for user in ops admin; do
+  home="/home/$user"
+  mkdir -p "$home/.ssh"
+  cp /keys/authorized_keys "$home/.ssh/authorized_keys"
+  chown -R "$user:$user" "$home/.ssh"
+  chmod 700 "$home/.ssh"
+  chmod 600 "$home/.ssh/authorized_keys"
+done
+
+mkdir -p /srv/www
+echo "hello from $(hostname)" > /srv/www/index.html
+python3 -m http.server 8081 --bind 127.0.0.1 --directory /srv/www >/dev/null 2>&1 &
+
+exec /usr/sbin/sshd -D -e

testenv/targets/sshd_config

@@ -0,0 +1,18 @@
+# Test targets accept the generated test key only. Port 2222 tests ssh.default_port.
+Port 22
+Port 2222
+ListenAddress 0.0.0.0
+ListenAddress ::
+HostKey /etc/ssh/ssh_host_ed25519_key
+PermitRootLogin no
+PasswordAuthentication no
+KbdInteractiveAuthentication no
+PubkeyAuthentication yes
+AuthorizedKeysFile .ssh/authorized_keys
+AllowTcpForwarding yes
+AllowAgentForwarding yes
+GatewayPorts no
+PermitTunnel no
+X11Forwarding no
+PrintMotd no
+Subsystem sftp /usr/lib/ssh/sftp-server

testenv/targets/target.Dockerfile

@@ -0,0 +1,16 @@
+# SSH target for the netssh test environment: every NetBox host, the bastion,
+# and the static host run this image with a different hostname.
+FROM alpine:3.23
+
+# Alpine locks new accounts with "!"; sshd refuses key logins for locked
+# accounts, so the password field is set to "*" (no password, not locked).
+RUN apk add --no-cache openssh-server openssh-sftp-server python3 \
+ && for user in ops admin; do \
+      adduser -D -s /bin/sh "$user" && sed -i "s/^$user:!/$user:*/" /etc/shadow; \
+    done
+
+COPY testenv/targets/sshd_config /etc/ssh/sshd_config
+COPY testenv/targets/entrypoint.sh /entrypoint.sh
+
+EXPOSE 22 2222
+ENTRYPOINT ["/entrypoint.sh"]

testenv/test.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Run the test scripts in the client container. Optional FILTER selects files
+# by substring, e.g. testenv/test.sh tunnel. The client is rebuilt first so the
+# tests always run the current source.
+set -euo pipefail
+cd "$(dirname "$0")"
+compose=(docker compose -f compose.yaml)
+if [ "${NO_BUILD:-}" != 1 ]; then
+  "${compose[@]}" build -q client
+  "${compose[@]}" up -d --wait client
+fi
+exec "${compose[@]}" exec -T client bash /tests/run.sh "${1:-}"

testenv/tests/01-cache.sh

@@ -0,0 +1,19 @@
+# Cache refresh across both NetBox instances, filters, list, search, clear.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+EOF
+
+expect_out "refresh both instances" "9 entries written" netssh cache refresh
+expect_out "list shows mgmt address" "fsn/fsn1-pve1.hoster.test  10.231.1.11" netssh cache list
+expect_out "list shows lab VM" "lab/web1                   10.231.1.42  vm" netssh cache list
+expect_out "IPv6-only host" "fsn/v6-host                fd00:30::60" netssh cache list
+expect_out "refresh one instance" "2 entries written" netssh cache refresh --instance lab
+expect_out "refresh by tag" "3 entries written" netssh cache refresh --tag pve
+expect_out "refresh by kind" "3 entries written" netssh cache refresh --kind vm
+expect_eq "search" "fsn/fsn1-pve1.hoster.test
+fsn/fsn1-pve2.hoster.test
+fsn/fsn1-pve3.hoster.test" bash -c 'netssh search fsn1 | sort'
+check "clear" netssh cache clear
+expect_eq "empty after clear" "" bash -c 'netssh search fsn'

testenv/tests/02-connect.sh

@@ -0,0 +1,29 @@
+# Connecting with the resolved address, default user and port, overrides.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+EOF
+
+expect_eq "connect via NetBox" "fsn1-pve1" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_eq "unique name without instance" "fsn1-pve2" netssh fsn1-pve2.hoster.test hostname
+expect_eq "default user" "ops" netssh fsn/fsn1-pve1.hoster.test whoami
+expect_eq "user@ wins" "admin" netssh admin@fsn/fsn1-pve1.hoster.test whoami
+expect_eq "-l wins" "admin" netssh -l admin fsn/fsn1-pve1.hoster.test whoami
+expect_eq "remote command with arguments" "a b" netssh fsn/fsn1-pve1.hoster.test echo a b
+expect_eq "dry run" "ssh -l ops 10.231.1.11" netssh --dry-run fsn/fsn1-pve1.hoster.test
+
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  default_port: 2222
+EOF
+expect_out "default port" " 2222" netssh fsn/fsn1-pve1.hoster.test 'echo $SSH_CONNECTION'
+expect_out "-p wins over default port" " 22" netssh -p 22 fsn/fsn1-pve1.hoster.test 'echo $SSH_CONNECTION'
+expect_eq "dry run with port" "ssh -p 2222 -l ops 10.231.1.11" netssh --dry-run fsn/fsn1-pve1.hoster.test
+expect_eq "version" "netssh" bash -c 'netssh --version | cut -d" " -f1'

testenv/tests/03-resolver.sh

@@ -0,0 +1,63 @@
+# Every resolver strategy against real NetBox data. cache.ttl 0 makes every
+# connection ask NetBox, so each config change takes effect immediately.
+jump='    - match: {instance: fsn}
+      proxy_jump: ops@10.231.0.30
+    - match: {name: "bastion*"}
+      proxy_jump: none'
+
+config <<EOF
+cache: {ttl: 0}
+resolver: {strategies: [primary_ip]}
+ssh:
+  default_user: ops
+  rules:
+$jump
+EOF
+expect_eq "primary_ip uses prod address via bastion" "ssh -l ops -J ops@10.231.0.30 10.231.2.11" netssh --dry-run fsn/fsn1-pve1.hoster.test
+expect_eq "primary_ip connects through the jump host" "fsn1-pve1" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_eq "bastion rule disables the jump" "ssh -l ops 10.231.0.30" netssh --dry-run fsn/bastion.hoster.test
+expect_eq "IPv6 primary address" "ssh -l ops -J ops@10.231.0.30 fd00:30::60" netssh --dry-run fsn/v6-host
+
+config <<'EOF'
+cache: {ttl: 0}
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh: {default_user: ops}
+EOF
+expect_eq "management_subnet" "ssh -l ops 10.231.1.12" netssh --dry-run fsn/fsn1-pve2.hoster.test
+expect_eq "management_subnet falls back to primary_ip" "ssh -l ops 10.231.2.21" netssh --dry-run fsn/web1
+
+config <<'EOF'
+cache: {ttl: 0}
+resolver:
+  strategies: [interface_name, primary_ip]
+  interface_name: mgmt0
+ssh: {default_user: ops}
+EOF
+expect_eq "interface_name" "ssh -l ops 10.231.1.13" netssh --dry-run fsn/fsn1-pve3.hoster.test
+expect_eq "interface_name connects" "fsn1-pve3" netssh fsn/fsn1-pve3.hoster.test hostname
+expect_eq "interface_name falls back for VMs" "ssh -l ops 10.231.2.22" netssh --dry-run fsn/web2
+
+# eth0 holds the prod address, which sorts after mgmt: catches an ignored filter.
+sed -i 's/interface_name: mgmt0/interface_name: eth0/' "$XDG_CONFIG_HOME/netssh.yaml"
+expect_eq "interface_name picks the named interface" "ssh -l ops 10.231.2.13" netssh --dry-run fsn/fsn1-pve3.hoster.test
+
+config <<'EOF'
+cache: {ttl: 0}
+resolver:
+  strategies: [hostname]
+  hostname_domain: example.org
+ssh: {default_user: ops}
+EOF
+expect_eq "hostname strategy" "ssh -l ops fsn1-pve1.hoster.test" netssh --dry-run fsn/fsn1-pve1.hoster.test
+expect_eq "hostname connects via DNS" "fsn1-pve1" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_eq "hostname domain for names without a dot" "ssh -l ops lab-db1.example.org" netssh --dry-run lab/lab-db1
+
+config <<'EOF'
+cache: {ttl: 0}
+resolver:
+  strategies: [interface_name]
+  interface_name: mgmt0
+EOF
+expect_fail "no strategy finds an address" "no strategy resolved an IP" netssh --dry-run fsn/web1

testenv/tests/04-instances.sh

@@ -0,0 +1,20 @@
+# Two NetBox instances: qualified names, ambiguity, an unreachable instance.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  rules:
+    - match: {kind: vm, instance: fsn}
+      proxy_jump: ops@10.231.0.30
+EOF
+expect_fail "same name in both instances is ambiguous" "found 2 exact matches" netssh --dry-run web1
+expect_eq "fsn/web1 through the bastion" "web1" netssh fsn/web1 hostname
+expect_eq "lab/web1 directly" "lab-web1" netssh lab/web1 hostname
+expect_eq "lab uses its v1 token" "lab-db1" netssh lab/lab-db1 hostname
+
+# lab unreachable: qualified fsn targets still work, unqualified ones need every instance.
+sed -i 's#http://10.231.0.21:8080#http://10.231.0.21:9#' "$XDG_CONFIG_HOME/netssh.yaml"
+expect_eq "qualified target with another instance down" "fsn1-pve1" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_fail "unqualified target needs every instance" "10.231.0.21:9" netssh --dry-run fsn1-pve1.hoster.test

testenv/tests/05-shortcuts.sh

@@ -0,0 +1,31 @@
+# Domains, hyphen folding, rewrite rules, alias --test, completion, aliases.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh: {default_user: ops}
+shortcuts:
+  domains: [.hoster.test]
+  rewrites:
+    - pattern: '^([a-z]+)[0-9]+-'
+      replace: '$1'
+EOF
+check "refresh" netssh cache refresh
+expect_eq "domain expansion via NetBox" "fsn1-pve1" netssh fsn/fsn1-pve1 hostname
+expect_eq "rewrite shortcut, qualified" "fsn1-pve2" netssh fsn/fsnpve2 hostname
+expect_eq "rewrite shortcut, unqualified" "fsn1-pve3" netssh fsnpve3 hostname
+expect_out "alias --test" "fsn1-pve1.hoster.test → fsnpve1" netssh alias --test fsn1-pve1.hoster.test
+expect_out "completion offers shortcuts" "fsnpve1" netssh __complete fsnp
+expect_out "aliases use the shortcut" "alias fsn_fsnpve1='netssh " netssh alias --shell bash
+expect_fail "unknown shortcut" "host not found" netssh --dry-run fsnpve9
+
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+shortcuts:
+  domains: [.hoster.test]
+  strip_hyphens: true
+EOF
+check "refresh" netssh cache refresh
+expect_eq "hyphen folding" "ssh 10.231.1.12" netssh --dry-run fsn/fsn1pve2

testenv/tests/06-ssh-options.sh

@@ -0,0 +1,34 @@
+# Jump hosts, rules, host key checking, connection target, options, extra args.
+known="$HOME/known_hosts"
+config <<EOF
+cache: {ttl: 0}
+resolver: {strategies: [primary_ip]}
+ssh:
+  default_user: ops
+  options:
+    UserKnownHostsFile: $known
+    ServerAliveInterval: "30"
+  extra_args: ["-T"]
+  rules:
+    - match: {tag: web}
+      proxy_jump: ops@10.231.0.30
+    - match: {tag: pve}
+      proxy_jump: ops@10.231.0.30
+      host_key_checking: strict
+    - match: {name: "fsn1-pve2*"}
+      host_key_checking: accept-new
+    - match: {name: "fsn1-pve3*"}
+      host_key_checking: "off"
+      target: name
+EOF
+expect_eq "rule by tag adds jump host" "ssh -T -l ops -J ops@10.231.0.30 -o serveraliveinterval=30 -o userknownhostsfile=$known 10.231.2.21" netssh --dry-run fsn/web1
+expect_eq "connect through rule jump" "web1" netssh fsn/web1 hostname
+expect_out "--no-jump removes it" "-o ProxyJump=none" netssh --dry-run --no-jump fsn/web1
+expect_out "--jump overrides it" "-J ops@10.231.0.30" netssh --dry-run --jump ops@10.231.0.30 fsn/v6-host
+expect_fail "strict rejects an unknown host key" "Host key verification failed" netssh fsn/fsn1-pve1.hoster.test hostname
+expect_eq "later rule accept-new wins" "fsn1-pve2" netssh fsn/fsn1-pve2.hoster.test hostname
+expect_out "accept-new stored the key" "10.231.2.12" cat "$known"
+expect_out "off prints a notice" "host key checking is disabled" netssh fsn/fsn1-pve3.hoster.test hostname
+expect_out "target name keeps the address" "-o HostName=10.231.2.13 -o HostKeyAlias=fsn1-pve3.hoster.test" netssh --dry-run fsn/fsn1-pve3.hoster.test
+expect_out "target name destination" " fsn1-pve3.hoster.test" netssh --dry-run fsn/fsn1-pve3.hoster.test
+expect_out "user -o wins over config" "-o ServerAliveInterval=5" netssh --dry-run -o ServerAliveInterval=5 fsn/web1

testenv/tests/07-static.sh

@@ -0,0 +1,25 @@
+# Static hosts without any NetBox: config, CLI, own user/port/options, rules.
+config_only <<'EOF'
+ssh:
+  default_user: ops
+  rules:
+    - match: {kind: static, tag: legacy}
+      options: {ServerAliveInterval: "15"}
+hosts:
+  - name: legacy-box
+    address: 10.231.0.50
+    user: admin
+    tags: [legacy]
+EOF
+expect_eq "connect to a static host" "legacy-box" netssh legacy-box hostname
+expect_eq "static user" "admin" netssh legacy-box whoami
+expect_out "rule by kind and tag" "-o serveraliveinterval=15" netssh --dry-run legacy-box
+expect_eq "-l still wins" "ops" netssh -l ops legacy-box whoami
+check "hosts add" netssh hosts add box2 10.231.0.50 --port 2222 --tag lab
+expect_eq "hosts list" "box2 10.231.0.50 2222 lab" bash -c 'netssh hosts list | grep "^box2" | tr -s " "' 
+expect_out "static port" " 2222" netssh box2 'echo $SSH_CONNECTION'
+expect_out "completion" "box2" netssh __complete bo
+expect_fail "duplicate" "already exists" netssh hosts add box2 10.0.0.1
+check "hosts remove" netssh hosts remove box2
+expect_fail "removed host is gone" "no NetBox is configured" netssh --dry-run box2
+expect_eq "sftp to a static host" "Remote working directory: /home/admin" bash -c 'echo pwd | netssh sftp -b - legacy-box | grep Remote'

testenv/tests/08-transfer.sh

@@ -0,0 +1,24 @@
+# sftp and scp: upload, download, jump host, IPv6, errors.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  rules:
+    - match: {kind: vm, instance: fsn}
+      proxy_jump: ops@10.231.0.30
+EOF
+echo "payload $$" >"$HOME/up.txt"
+check "scp upload" netssh scp "$HOME/up.txt" fsn/fsn1-pve1.hoster.test:/tmp/up.txt
+expect_eq "uploaded content" "payload $$" netssh fsn/fsn1-pve1.hoster.test cat /tmp/up.txt
+check "scp download" netssh scp fsn/fsn1-pve1.hoster.test:/tmp/up.txt "$HOME/down.txt"
+expect_eq "downloaded content" "payload $$" cat "$HOME/down.txt"
+check "scp to a VM through the bastion" netssh scp "$HOME/up.txt" fsn/web1:/tmp/up.txt
+expect_eq "VM content" "payload $$" netssh fsn/web1 cat /tmp/up.txt
+check "scp to IPv6 host" netssh scp "$HOME/up.txt" fsn/v6-host:/tmp/v6.txt
+expect_eq "IPv6 content" "payload $$" netssh fsn/v6-host cat /tmp/v6.txt
+expect_out "sftp starts in the path" "Remote working directory: /tmp" bash -c 'echo pwd | netssh sftp -b - fsn/fsn1-pve2.hoster.test:/tmp'
+expect_out "sftp to IPv6 host" "v6.txt" bash -c 'echo "ls /tmp" | netssh sftp -b - fsn/v6-host'
+expect_out "sftp through the bastion" "up.txt" bash -c 'echo "ls /tmp" | netssh sftp -b - fsn/web1'
+expect_fail "two remote hosts" "not supported" netssh scp fsn/web1:/a fsn/web2:/b

testenv/tests/09-tunnel.sh

@@ -0,0 +1,40 @@
+# Port forwards: named, ad hoc, --forward with a shell, port in use.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  forwards:
+    web: {local: "18081:127.0.0.1:8081"}
+  rules:
+    - match: {kind: vm, instance: fsn}
+      proxy_jump: ops@10.231.0.30
+EOF
+tunnel_test() { # NAME PORT WANT ARGS...
+  local name=$1 port=$2 want=$3 pid out
+  shift 3
+  "$@" >"$HOME/tunnel.log" 2>&1 &
+  pid=$!
+  if wait_for 15 curl -sf "http://127.0.0.1:$port/"; then
+    out=$(curl -s "http://127.0.0.1:$port/")
+    [[ $out == *"$want"* ]] && ok "$name" || bad "$name" "curl: $out"
+  else
+    bad "$name" "tunnel did not open: $(cat "$HOME/tunnel.log")"
+  fi
+  kill "$pid" 2>/dev/null
+  wait "$pid" 2>/dev/null
+}
+tunnel_test "named forward" 18081 "hello from fsn1-pve1" netssh tunnel fsn/fsn1-pve1.hoster.test web
+expect_out "tunnel notice" "forwarding -L 18081:127.0.0.1:8081 via fsn1-pve1.hoster.test" cat "$HOME/tunnel.log"
+tunnel_test "ad hoc spec through the bastion" 18082 "hello from web1" netssh tunnel fsn/web1 18082:127.0.0.1:8081
+tunnel_test "--forward with a remote command" 18081 "hello from fsn1-pve2" netssh --forward web fsn/fsn1-pve2.hoster.test sleep 30
+
+netssh tunnel fsn/fsn1-pve1.hoster.test web >/dev/null 2>&1 &
+holder=$!
+wait_for 15 curl -sf http://127.0.0.1:18081/
+expect_fail "port in use fails instead of hanging" "Address in use" timeout 20 netssh tunnel fsn/fsn1-pve2.hoster.test web
+kill "$holder"; wait "$holder" 2>/dev/null
+
+expect_fail "unknown forward lists the configured ones" "available: web" netssh tunnel fsn/fsn1-pve1.hoster.test db
+expect_fail "tunnel without forward" "forwards for fsn/fsn1-pve1.hoster.test: web" netssh tunnel fsn/fsn1-pve1.hoster.test

testenv/tests/10-notes.sh

@@ -0,0 +1,22 @@
+# Local notes and NetBox comments (v2 token on fsn, v1 token on lab).
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+EOF
+check "refresh" netssh cache refresh
+host=fsn/fsn1-pve1.hoster.test
+check "set local note" netssh notes set $host "first line"
+check "append local note" netssh notes append $host "second line"
+expect_eq "show local note" "first line
+second line" netssh notes show $host
+expect_eq "note from stdin" "piped" bash -c "echo piped | netssh notes set $host && netssh notes show $host"
+
+expect_eq "read NetBox comments (v2 token)" "Proxmox node 1" netssh notes show $host --netbox
+check "append NetBox comments" netssh notes append $host --netbox "checked by netssh test"
+expect_out "NetBox has the new line" "checked by netssh test" curl -s -H "Authorization: Bearer $FSN_TOKEN" "$FSN_URL/api/dcim/devices/?name=fsn1-pve1.hoster.test"
+check "restore NetBox comments" netssh notes set $host --netbox "Proxmox node 1"
+
+check "set NetBox comments (v1 token)" netssh notes set lab/lab-db1 --netbox "lab note"
+expect_eq "read them back" "lab note" netssh notes show lab/lab-db1 --netbox
+check "clear them" netssh notes set lab/lab-db1 --netbox ""

testenv/tests/11-shell.sh

@@ -0,0 +1,32 @@
+# Completion, aliases, hook install for bash, zsh, fish, and the command alias.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  forwards:
+    web: {local: "18081:127.0.0.1:8081"}
+shortcuts:
+  domains: [.hoster.test]
+shell:
+  alias: j
+EOF
+check "refresh" netssh cache refresh
+expect_out "complete hosts" "fsn/fsn1-pve2.hoster.test" netssh __complete fsn/fsn1
+expect_out "complete scp host:" "fsn/fsn1-pve1.hoster.test:" netssh __complete scp a.txt fsn/fsn1-pve1
+expect_out "complete forwards after the host" "web" netssh __complete tunnel fsn/fsn1-pve1.hoster.test ""
+expect_out "complete --forward" "web" netssh __complete --forward ""
+expect_out "fish aliases" "alias fsn_fsn1-pve1 " netssh alias --shell fish
+
+check "hook install bash" netssh hook install --shell bash
+# Interactive bash without a terminal warns about job control on stderr.
+expect_eq "bash loads host aliases" "fsn1-pve1" sh -c "bash -ic 'fsn_fsn1-pve1 hostname' 2>/dev/null </dev/null"
+expect_eq "bash command alias" "fsn1-pve2" sh -c "bash -ic 'j fsn/fsn1-pve2.hoster.test hostname' 2>/dev/null </dev/null"
+check "hook install zsh" netssh hook install --shell zsh
+expect_eq "zsh loads host aliases" "fsn1-pve3" zsh -ic 'fsn_fsn1-pve3 hostname' </dev/null
+mkdir -p "$XDG_CONFIG_HOME/fish"
+check "hook install fish" netssh hook install --shell fish
+expect_eq "fish loads host aliases" "fsn1-pve1" fish -c 'fsn_fsn1-pve1 hostname' </dev/null
+check "completion install bash" netssh completion install --shell bash
+expect_out "bash completes hosts" "fsn/fsn1-pve2.hoster.test" bash -ic '. ~/.local/share/bash-completion/completions/netssh; COMP_WORDS=(netssh fsn/fsn1-pve2); COMP_CWORD=1; COMP_LINE="netssh fsn/fsn1-pve2"; COMP_POINT=${#COMP_LINE}; __start_netssh netssh; printf "%s\n" "${COMPREPLY[@]}"' </dev/null

testenv/tests/12-tui.sh

@@ -0,0 +1,64 @@
+# The interactive TUI, driven through tmux: search, connect, sftp, tunnel, edit.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  forwards:
+    web: {local: "18085:127.0.0.1:8081"}
+EOF
+check "refresh" netssh cache refresh
+export TMUX_TMPDIR="$HOME/tmux"
+mkdir -p "$TMUX_TMPDIR"
+
+screen() { tmux capture-pane -p -t tui; }
+shows() { screen | grep -qF -- "$1"; }
+tui() { # start netssh in a fresh tmux session
+  tmux kill-server 2>/dev/null
+  tmux new-session -d -s tui -x 160 -y 40 -e HOME="$HOME" -e XDG_CONFIG_HOME="$XDG_CONFIG_HOME" -e XDG_CACHE_HOME="$XDG_CACHE_HOME" netssh
+  wait_for 10 shows "Search hostname"
+}
+step() { # NAME TEXT — wait until the pane shows TEXT
+  if wait_for 15 shows "$2"; then ok "$1"; else bad "$1" "$(screen)"; fi
+}
+
+tui && ok "TUI starts" || bad "TUI starts" "$(screen)"
+tmux send-keys -t tui "fsn1-pve2"
+step "search shows the host" "fsn/fsn1-pve2.hoster.test"
+tmux send-keys -t tui Enter
+sleep 1
+tmux send-keys -t tui "hostname" Enter
+step "enter connects" "fsn1-pve2"
+tmux send-keys -t tui "exit" Enter
+
+tui
+tmux send-keys -t tui "fsn1-pve3"
+wait_for 10 shows "fsn/fsn1-pve3.hoster.test"
+tmux send-keys -t tui C-o
+step "ctrl+o opens sftp" "sftp>"
+tmux send-keys -t tui "pwd" Enter
+step "sftp works" "Remote working directory: /home/ops"
+tmux send-keys -t tui "bye" Enter
+
+tui
+tmux send-keys -t tui "fsn1-pve1"
+wait_for 10 shows "fsn/fsn1-pve1.hoster.test"
+tmux send-keys -t tui C-t
+step "ctrl+t lists configured forwards" "forwards: web"
+tmux send-keys -t tui "web" Enter
+step "tunnel notice" "forwarding -L 18085:127.0.0.1:8081"
+expect_out "tunnel from the TUI works" "hello from fsn1-pve1" curl -s --retry 10 --retry-connrefused --retry-delay 1 http://127.0.0.1:18085/
+tmux send-keys -t tui C-c
+
+tui
+tmux send-keys -t tui "fsn1-pve1"
+wait_for 10 shows "fsn/fsn1-pve1.hoster.test"
+tmux send-keys -t tui C-e
+step "ctrl+e opens the editor" "Connect as: ops@fsn/fsn1-pve1.hoster.test:22"
+tmux send-keys -t tui C-u "admin@fsn/fsn1-pve1.hoster.test:22" Enter
+sleep 1
+tmux send-keys -t tui "whoami" Enter
+step "edited user is used" "admin"
+tmux send-keys -t tui "exit" Enter
+tmux kill-server 2>/dev/null

testenv/tests/13-configure.sh

@@ -0,0 +1,9 @@
+# The configurator in huh's accessible mode: without NetBox, add a static host,
+# save, then connect. Menu numbers follow the order in internal/setup.
+config_only </dev/null
+rm -f "$XDG_CONFIG_HOME/netssh.yaml"
+#                          no NetBox, static hosts, add, name, address, user, port, tags, back, save
+out=$(python3 /tests/drive.py 2 4 1 legacy-box 10.231.0.50 admin "" legacy 5 9)
+[[ $out == *"Config saved"* ]] && ok "configure saves" || bad "configure saves" "$out"
+expect_out "config has the host" 'address: "10.231.0.50"' cat "$XDG_CONFIG_HOME/netssh.yaml"
+expect_eq "connect to the configured host" "admin" netssh legacy-box whoami

testenv/tests/14-uninstall.sh

@@ -0,0 +1,12 @@
+# Uninstall in dry-run mode lists everything netssh created.
+config <<'EOF'
+resolver: {strategies: [primary_ip]}
+EOF
+check "refresh" netssh cache refresh
+check "hook install" netssh hook install --shell bash
+expect_out "lists the profile" ".bashrc" netssh uninstall --dry-run
+expect_out "lists the config" "netssh.yaml" netssh uninstall --dry-run
+expect_out "lists the cache" ".cache/netssh" netssh uninstall --dry-run
+out=$(netssh uninstall --dry-run --keep-config 2>&1)
+[[ $out != *"netssh.yaml"* ]] && ok "--keep-config keeps the config" || bad "--keep-config keeps the config" "$out"
+expect_out "nothing was removed" "netssh shell-init" cat "$HOME/.bashrc"

testenv/tests/15-multi.sh

@@ -0,0 +1,74 @@
+# netssh multi with real tmux and zellij: selectors against NetBox, panes,
+# broadcast typing reaching every host, netssh sync, zellij layouts and tabs.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh:
+  default_user: ops
+  rules:
+    - match: {kind: vm, instance: fsn}
+      proxy_jump: ops@10.231.0.30
+groups:
+  pve: ["cluster:pve-fsn1"]
+  mixed: ["@pve", "lab/lab-db1", "tag:web"]
+EOF
+check "refresh" netssh cache refresh
+nodes="fsn/fsn1-pve1.hoster.test fsn/fsn1-pve2.hoster.test fsn/fsn1-pve3.hoster.test"
+expect_out "cluster: selects the devices" "# 3 hosts: $nodes" netssh multi --dry-run --tmux cluster:pve-fsn1
+expect_out "--kind vm selects the VMs" "# 2 hosts: fsn/web1 fsn/web2" netssh multi --dry-run --tmux --kind vm cluster:pve-fsn1
+expect_out "groups, tags, and hosts combined" "# 7 hosts: $nodes lab/lab-db1 fsn/web1 fsn/web2 lab/web1" netssh multi --dry-run --tmux @mixed
+expect_fail "unknown cluster" "matches no hosts" netssh multi --dry-run --tmux cluster:nope
+expect_out "completion offers clusters" "cluster:pve-fsn1" netssh __complete multi cluster:
+expect_out "completion offers groups" "@pve" netssh __complete multi @
+
+export TMUX_TMPDIR="$HOME/tmux"
+mkdir -p "$TMUX_TMPDIR" "$HOME/.config/zellij"
+# No first-start tips or release notes on top of the panes.
+printf 'show_startup_tips false\nshow_release_notes false\n' >"$HOME/.config/zellij/config.kdl"
+envs=(-e HOME="$HOME" -e XDG_CONFIG_HOME="$XDG_CONFIG_HOME" -e XDG_CACHE_HOME="$XDG_CACHE_HOME")
+hosts_of() { tmux list-panes -t "$1" -F '#{@netssh_host}' 2>/dev/null | sort | tr '\n' ' '; }
+# wait_for retries a command, so checks must re-evaluate on every call.
+panes_in() { [ "$(tmux list-panes -t "$1" 2>/dev/null | wc -l)" = "$2" ]; }
+sync_is() { [ "$(tmux show-window-options -t "$1" -v synchronize-panes 2>/dev/null)" = "$2" ]; }
+prompts() { [ "$(tmux capture-pane -p -t z | grep -o 'fsn1-pve[123]:~\$' | sort -u | wc -l)" = 3 ]; }
+remote_file() { for n in 1 2 3; do netssh "fsn/fsn1-pve$n.hoster.test" test -f "$1" || return 1; done; }
+
+# Inside tmux: a new window in the current session, broadcast from the start.
+tmux new-session -d -s outer -x 200 -y 60 "${envs[@]}" bash
+tmux send-keys -t outer "netssh multi --sync @pve" Enter
+if wait_for 20 panes_in outer:pve 3; then ok "tmux: three panes in a new window"; else bad "tmux: three panes in a new window" "$(tmux list-windows -a)"; fi
+expect_eq "tmux: panes are labelled" "$nodes " hosts_of outer:pve
+expect_eq "tmux: broadcast is on" "on" tmux show-window-options -t outer:pve -v synchronize-panes
+sleep 2
+marker="/tmp/netssh-multi-$$"
+tmux send-keys -t outer:pve "touch $marker" Enter
+if wait_for 15 remote_file "$marker"; then ok "tmux: one command reached all three hosts"; else bad "tmux: one command reached all three hosts" "$(tmux capture-pane -p -t outer:pve)"; fi
+
+tmux new-window -t outer -n ctl "${envs[@]}" bash
+tmux send-keys -t outer:ctl "netssh sync" Enter
+if wait_for 10 sync_is outer:ctl on; then ok "netssh sync toggles broadcast"; else bad "netssh sync toggles broadcast" "$(tmux capture-pane -p -t outer:ctl)"; fi
+
+# Outside tmux: a new session, attached.
+tmux send-keys -t outer:ctl "netssh sync; env -u TMUX netssh multi --kind vm cluster:pve-fsn1" Enter
+if wait_for 20 panes_in netssh-pve-fsn1 2; then ok "tmux: new session outside tmux"; else bad "tmux: new session outside tmux" "$(tmux list-sessions)"; fi
+expect_eq "tmux: VMs through the bastion" "fsn/web1 fsn/web2 " hosts_of netssh-pve-fsn1
+tmux kill-server
+
+# zellij outside a session: netssh starts zellij with a grid layout.
+tmux new-session -d -s z -x 200 -y 60 "${envs[@]}" bash
+tmux send-keys -t z "netssh multi --zellij @pve" Enter
+zscreen() { tmux capture-pane -p -t z; }
+if wait_for 30 prompts; then ok "zellij: three panes with remote shells"; else bad "zellij: three panes with remote shells" "$(zscreen)"; fi
+expect_out "zellij: pane titles" "fsn/fsn1-pve2.hoster.test" zscreen
+zsession() { zellij list-sessions --short --no-formatting 2>/dev/null | head -1 | grep .; }
+if wait_for 10 zsession; then ok "zellij: session is running"; else bad "zellij: session is running" "$(zellij list-sessions 2>&1)"; fi
+session=$(zsession)
+
+# zellij inside that session: netssh multi adds a tab.
+ZELLIJ_SESSION_NAME=$session ZELLIJ=0 netssh multi --kind vm cluster:pve-fsn1 >/dev/null 2>&1
+expect_out "zellij: new tab inside a session" "pve-fsn1" zellij --session "$session" action query-tab-names
+expect_out "zellij: tab layout runs netssh for the VMs" "fsn/web2" zellij --session "$session" action dump-layout
+zellij kill-all-sessions --yes >/dev/null 2>&1
+tmux kill-server 2>/dev/null
+true

testenv/tests/16-render.sh

@@ -0,0 +1,102 @@
+# What a user sees: tmux, zellij, and the TUI rendered by a real terminal
+# emulator (xterm on Xvfb), checked by OCR of screenshots. The screenshots stay
+# in testenv/.artifacts/ for a look by eye.
+config <<'EOF'
+resolver:
+  strategies: [management_subnet, primary_ip]
+  management_subnets: [10.231.1.0/24]
+ssh: {default_user: ops}
+groups:
+  pve: ["cluster:pve-fsn1"]
+EOF
+check "refresh" netssh cache refresh
+export TMUX_TMPDIR="$HOME/tmux"
+mkdir -p "$TMUX_TMPDIR" "$HOME/.config/zellij"
+printf 'show_startup_tips false\nshow_release_notes false\n' >"$HOME/.config/zellij/config.kdl"
+start_screen && ok "X server and xterm" || bad "X server and xterm" "Xvfb did not start"
+
+p1=fsn/fsn1-pve1.hoster.test p2=fsn/fsn1-pve2.hoster.test p3=fsn/fsn1-pve3.hoster.test
+prompts() { screen_shows "$1" "fsn1-pve1:~\$" "fsn1-pve2:~\$" "fsn1-pve3:~\$"; }
+# Two hosts on one OCR line means their panes sit side by side (tiled grid).
+side_by_side() { screen_text "$1" | ocr_norm | grep -F "$(printf %s "$2" | ocr_norm)" | grep -qF "$(printf %s "$3" | ocr_norm)"; }
+visible() { # NAME SHOT TEXT... — wait until the screen shows every TEXT
+  local name=$1 shot=$2
+  shift 2
+  if wait_for 30 screen_shows "$shot" "$@"; then ok "$name"; else bad "$name" "$(screen_text "$shot")"; fi
+}
+
+# --- tmux, started from a plain terminal: new session, attached in xterm ---
+term netssh multi --sync @pve
+visible "tmux: three remote shells on screen" tmux-1 "fsn1-pve1:~\$" "fsn1-pve2:~\$" "fsn1-pve3:~\$"
+visible "tmux: borders show host and [SYNC]" tmux-1 "$p1 [SYNC]" "$p2 [SYNC]" "$p3 [SYNC]"
+side_by_side tmux-1 "$p1" "$p2" && ok "tmux: tiled, first two panes side by side" || bad "tmux: tiled, first two panes side by side" "$(screen_text tmux-1)"
+tmux send-keys -t netssh-pve "echo typed-once-\$(hostname)" Enter
+visible "tmux: broadcast output in every pane" tmux-2 "typed-once-fsn1-pve1" "typed-once-fsn1-pve2" "typed-once-fsn1-pve3"
+# Keys as typed in xterm (send-keys -K goes through the client's prefix and
+# key tables): prefix e excludes the active pane, prefix S toggles all panes.
+client=$(tmux list-clients -t netssh-pve -F '#{client_name}' | head -1)
+press() { tmux send-keys -K -c "$client" C-b "$1"; sleep 0.5; }
+panes=($(tmux list-panes -t netssh-pve -F '#{pane_id}'))
+tmux select-pane -t "${panes[2]}"
+press e
+visible "tmux: prefix e marks the pane [SOLO]" tmux-solo "$p3 [SOLO]" "$p1 [SYNC]" "$p2 [SYNC]"
+tmux send-keys -t "${panes[2]}" "echo solo-only" Enter
+tmux send-keys -t "${panes[0]}" "echo two-panes" Enter
+sleep 1
+shot tmux-solo-2
+[ "$(screen_count tmux-solo-2 "solo-only")" = 2 ] && ok "tmux: the excluded pane types alone" || bad "tmux: the excluded pane types alone" "$(screen_text tmux-solo-2)"
+[ "$(screen_count tmux-solo-2 "two-panes")" = 4 ] && ok "tmux: broadcast skips the excluded pane" || bad "tmux: broadcast skips the excluded pane" "$(screen_text tmux-solo-2)"
+press e
+visible "tmux: prefix e again includes it" tmux-solo-3 "$p3 [SYNC]"
+
+press S
+sync_is() { [ "$(tmux show-window-options -t netssh-pve -v synchronize-panes 2>/dev/null)" = "$1" ]; }
+wait_for 5 sync_is off && ok "tmux: prefix S turns broadcast off" || bad "tmux: prefix S turns broadcast off" "$(tmux show-window-options -t netssh-pve)"
+tmux send-keys -t netssh-pve "echo just-this-pane" Enter
+sleep 1
+shot tmux-3
+[ "$(screen_count tmux-3 "just-this-pane")" = 2 ] && ok "tmux: without broadcast only one pane gets input" || bad "tmux: without broadcast only one pane gets input" "$(screen_text tmux-3)"
+shows_sync() { screen_shows tmux-3 "[SYNC]"; }
+shows_sync && bad "tmux: [SYNC] disappears when broadcast is off" "$(screen_text tmux-3)" || ok "tmux: [SYNC] disappears when broadcast is off"
+press S
+wait_for 5 sync_is on && ok "tmux: prefix S turns it on again" || bad "tmux: prefix S turns it on again" "$(tmux show-window-options -t netssh-pve)"
+tmux kill-server
+
+# --- more hosts than panes_per_window: further windows ---
+sed -i 's/^groups:/multi: {panes_per_window: 2}\ngroups:/' "$XDG_CONFIG_HOME/netssh.yaml"
+term netssh multi @pve
+visible "tmux: hosts split over windows pve-1 and pve-2" tmux-windows "pve-1" "pve-2"
+visible "tmux: status bar shows the whole session name" tmux-windows "[netssh-pve]"
+tmux kill-server
+sed -i '/^multi: {panes_per_window: 2}$/d' "$XDG_CONFIG_HOME/netssh.yaml"
+
+# --- zellij: generated grid layout, broadcast through the sync tab ---
+term netssh multi --zellij @pve
+visible "zellij: three remote shells on screen" zellij-1 "fsn1-pve1:~\$" "fsn1-pve2:~\$" "fsn1-pve3:~\$"
+visible "zellij: pane titles show the hosts" zellij-1 "$p1" "$p2" "$p3"
+side_by_side zellij-1 "$p1" "$p2" && ok "zellij: grid, first two panes side by side" || bad "zellij: grid, first two panes side by side" "$(screen_text zellij-1)"
+session=$(zellij list-sessions --short --no-formatting 2>/dev/null | head -1)
+zellij --session "$session" action toggle-active-sync-tab
+zellij --session "$session" action write-chars 'echo zellij-$(hostname)'
+zellij --session "$session" action write 13
+visible "zellij: broadcast output in every pane" zellij-2 "zellij-fsn1-pve1" "zellij-fsn1-pve2" "zellij-fsn1-pve3"
+zellij kill-all-sessions --yes >/dev/null 2>&1
+
+# --- TUI: mark hosts, open them together ---
+term tmux new-session -s tui netssh
+visible "TUI: search screen" tui-1 "Search hostname"
+# The netssh keys do nothing outside netssh multi windows.
+tmux source-file "$XDG_CACHE_HOME/netssh/netssh-multi.tmux.conf"
+client=$(tmux list-clients -t tui -F '#{client_name}' | head -1)
+tmux send-keys -K -c "$client" C-b S
+sleep 0.5
+[ "$(tmux show-window-options -t tui -v synchronize-panes 2>/dev/null)" != on ] && ok "tmux: prefix S leaves other windows alone" || bad "tmux: prefix S leaves other windows alone" "synchronize-panes turned on in a non-netssh window"
+tmux send-keys -t tui "pve"
+visible "TUI: results listed" tui-2 "$p1" "$p2" "$p3"
+tmux send-keys -t tui C-a
+visible "TUI: all marked" tui-3 "3 marked"
+tmux send-keys -t tui Enter
+visible "TUI: marked hosts open side by side" tui-4 "fsn1-pve1:~\$" "fsn1-pve2:~\$" "fsn1-pve3:~\$"
+tmux kill-server
+
+stop_screen

testenv/tests/drive.py

@@ -0,0 +1,32 @@
+"""Drive `netssh configure` in huh's accessible mode (TERM=dumb): one answer
+per prompt, sent after a short pause so each form reads its own line."""
+import os
+import pty
+import select
+import sys
+import time
+
+answers = sys.argv[1:]
+pid, fd = pty.fork()
+if pid == 0:
+    os.execvpe("netssh", ["netssh", "configure"], dict(os.environ, TERM="dumb"))
+out = b""
+
+
+def drain(seconds):
+    global out
+    end = time.time() + seconds
+    while time.time() < end:
+        ready, _, _ = select.select([fd], [], [], 0.05)
+        if ready:
+            try:
+                out += os.read(fd, 4096)
+            except OSError:
+                return
+
+
+for answer in answers:
+    drain(0.5)
+    os.write(fd, (answer + "\n").encode())
+drain(2)
+sys.stdout.write(out.decode(errors="replace"))

testenv/tests/lib.sh

@@ -0,0 +1,154 @@
+# Helpers for the netssh test environment. Sourced by run.sh, the tests, and
+# shell.sh inside the client container.
+
+# shellcheck disable=SC1091
+. /state/env
+RESULTS=${RESULTS:-/tmp/netssh-results}
+
+# new_home gives each test file its own netssh config, cache, notes, and rc files.
+new_home() {
+  HOME=$(mktemp -d /tmp/home.XXXXXX)
+  export HOME XDG_CONFIG_HOME="$HOME/.config" XDG_CACHE_HOME="$HOME/.cache" SHELL=/bin/bash
+  mkdir -p "$XDG_CONFIG_HOME" "$XDG_CACHE_HOME"
+  unset TMUX ZELLIJ NETSSH_NETBOX_URL NETSSH_NETBOX_TOKEN
+  cd "$HOME" || exit 1
+}
+
+# base_config prints both NetBox instances followed by stdin.
+base_config() { cat /state/netssh.yaml -; }
+
+# config writes the netssh config: both NetBox instances plus stdin.
+config() { base_config >"$XDG_CONFIG_HOME/netssh.yaml"; }
+
+# config_only writes stdin as the whole config (no NetBox).
+config_only() { cat >"$XDG_CONFIG_HOME/netssh.yaml"; }
+
+ok() {
+  echo "ok $CURRENT: $1" >>"$RESULTS"
+  printf '  \033[32mok\033[0m    %s\n' "$1"
+}
+bad() {
+  echo "FAIL $CURRENT: $1" >>"$RESULTS"
+  printf '  \033[31mFAIL\033[0m  %s\n' "$1"
+  printf '%s\n' "$2" | sed 's/^/        /'
+}
+
+# check NAME CMD... — CMD must succeed.
+check() {
+  local name=$1 out
+  shift
+  if out=$("$@" 2>&1); then ok "$name"; else bad "$name" "exit $?: $out"; fi
+}
+
+# expect_out NAME WANT CMD... — CMD must succeed and print WANT (substring).
+expect_out() {
+  local name=$1 want=$2 out rc
+  shift 2
+  out=$("$@" 2>&1) && rc=0 || rc=$?
+  if [ "$rc" = 0 ] && [[ $out == *"$want"* ]]; then ok "$name"; else bad "$name" "want: $want
+got (exit $rc): $out"; fi
+}
+
+# expect_eq NAME WANT CMD... — CMD must succeed and print exactly WANT.
+expect_eq() {
+  local name=$1 want=$2 out rc
+  shift 2
+  out=$("$@" 2>&1) && rc=0 || rc=$?
+  if [ "$rc" = 0 ] && [ "$out" = "$want" ]; then ok "$name"; else bad "$name" "want: $want
+got (exit $rc): $out"; fi
+}
+
+# expect_fail NAME WANT CMD... — CMD must fail and print WANT (substring).
+expect_fail() {
+  local name=$1 want=$2 out rc
+  shift 2
+  out=$("$@" 2>&1) && rc=0 || rc=$?
+  if [ "$rc" != 0 ] && [[ $out == *"$want"* ]]; then ok "$name"; else bad "$name" "want failure with: $want
+got (exit $rc): $out"; fi
+}
+
+# wait_for TIMEOUT CMD... — retry CMD every 0.2 s until it succeeds.
+wait_for() {
+  local deadline=$((SECONDS + $1))
+  shift
+  until "$@" >/dev/null 2>&1; do
+    [ $SECONDS -ge $deadline ] && return 1
+    sleep 0.2
+  done
+}
+
+# --- rendering in a real terminal emulator (tests/16-render.sh) ---
+# Xvfb provides a screen, xterm renders the terminal, `import` takes a
+# screenshot, and tesseract reads it back, so checks see what a user sees.
+
+start_screen() {
+  Xvfb :99 -screen 0 1920x1080x24 -nolisten tcp >/dev/null 2>&1 &
+  XVFB_PID=$!
+  export DISPLAY=:99
+  wait_for 10 import -window root -crop 1x1+0+0 null:
+}
+
+stop_screen() {
+  pkill -u "$(id -u)" xterm 2>/dev/null
+  kill "$XVFB_PID" 2>/dev/null
+  wait "$XVFB_PID" 2>/dev/null
+}
+
+# term CMD... — run CMD in a full-screen xterm (UTF-8, DejaVu Sans Mono).
+term() {
+  pkill -u "$(id -u)" xterm 2>/dev/null
+  xterm -u8 -geometry 190x52+0+0 -fa 'DejaVu Sans Mono' -fs 11 -bg '#1e1e1e' -fg '#d4d4d4' \
+    -T netssh -e "$@" >/dev/null 2>&1 &
+  sleep 1
+}
+
+# shot NAME — screenshot to /artifacts/NAME.png.
+shot() { import -window root "/artifacts/$1.png"; }
+
+# OCR preprocessing variants: no single one reads everything (dim hint lines,
+# red/green borders): plain luminance, stretched dark range for dim gray, and
+# the brightest color channel for colored text.
+OCR_VARIANTS=("-colorspace gray" "-colorspace gray -level 10%,40%"
+  "-channel RGB -separate -evaluate-sequence max -level 10%,60%")
+
+# ocr_variant NAME I — OCR of screenshot NAME with preprocessing variant I.
+ocr_variant() {
+  # shellcheck disable=SC2086
+  magick "/artifacts/$1.png" ${OCR_VARIANTS[$2]} -negate -resize 300% png:- |
+    tesseract stdin stdout --psm 6 2>/dev/null
+}
+
+# screen_text NAME — the text of all variants combined.
+screen_text() {
+  local i
+  for i in "${!OCR_VARIANTS[@]}"; do ocr_variant "$1" "$i"; done
+}
+
+# ocr_norm maps characters OCR confuses in DejaVu Sans Mono (1/l/I/|, C/( , 0/O,
+# typographic dashes for "-") to one form; expected text gets the same mapping,
+# so comparisons stay strict about everything else.
+ocr_norm() { sed 's/[‐‑‒–—―−]/-/g' | tr 'lI|(O' '111C0'; }
+
+# screen_shows NAME TEXT... — take a screenshot and check that OCR finds every TEXT.
+screen_shows() {
+  local name=$1 text want
+  shift
+  shot "$name"
+  text=$(screen_text "$name" | ocr_norm)
+  for want in "$@"; do
+    want=$(printf '%s' "$want" | ocr_norm)
+    [[ $text == *"$want"* ]] || return 1
+  done
+}
+
+# screen_count NAME TEXT — how often TEXT is on screenshot NAME: the highest
+# count of any OCR variant (they read the same screen, so they are not added).
+screen_count() {
+  local want i n max=0
+  want=$(printf '%s' "$2" | ocr_norm)
+  for i in "${!OCR_VARIANTS[@]}"; do
+    n=$(ocr_variant "$1" "$i" | ocr_norm | grep -oF -- "$want" | wc -l)
+    [ "$n" -gt "$max" ] && max=$n
+  done
+  echo "$max"
+}

testenv/tests/run.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Runs every tests/NN-*.sh (or those matching $1) in a fresh netssh home and
+# prints a summary. Exit code 1 if any check failed.
+set -u
+export RESULTS=/tmp/netssh-results
+: >"$RESULTS"
+filter=${1:-}
+for file in /tests/[0-9][0-9]-*.sh; do
+  name=$(basename "$file" .sh)
+  [[ -n $filter && $name != *"$filter"* ]] && continue
+  echo "== $name"
+  (
+    export CURRENT=$name
+    . /tests/lib.sh
+    new_home
+    . "$file"
+  )
+done
+passed=$(grep -c '^ok ' "$RESULTS" || true)
+failed=$(grep -c '^FAIL ' "$RESULTS" || true)
+echo
+echo "passed: $passed, failed: $failed"
+if [ "$failed" -gt 0 ]; then
+  grep '^FAIL ' "$RESULTS" | sed 's/^/  /'
+  exit 1
+fi

testenv/up.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Start the netssh test environment: generate the test key, build the images
+# (netssh from the current source), start everything, and seed NetBox.
+set -euo pipefail
+cd "$(dirname "$0")"
+compose=(docker compose -f compose.yaml)
+
+mkdir -p .keys .state .artifacts
+chmod a+rwx .state .artifacts # written by the container user (screenshots in .artifacts)
+if [ ! -f .keys/id_ed25519 ]; then
+  ssh-keygen -q -t ed25519 -N '' -C netssh-test -f .keys/id_ed25519
+  cp .keys/id_ed25519.pub .keys/authorized_keys
+fi
+# Throwaway test key: readable by the container user; tests copy it with 0600.
+chmod 644 .keys/id_ed25519 .keys/authorized_keys
+
+"${compose[@]}" build
+"${compose[@]}" up -d --wait --wait-timeout 600 \
+  postgres redis netbox-fsn netbox-lab bastion fsn1-pve1 fsn1-pve2 fsn1-pve3 \
+  web1 web2 lab-db1 lab-web1 legacy-box v6-host client
+"${compose[@]}" run --rm seed
+echo
+echo "Test environment is up."
+echo "  Tests:        testenv/test.sh [FILTER]"
+echo "  Shell:        testenv/shell.sh"
+echo "  NetBox UI:    http://127.0.0.1:18000 (fsn), http://127.0.0.1:18001 (lab) — admin / admin"