Author: Scott Peterman License: GPL-3.0 Status: Released. Every pillar is standing, the whole loop — crawl to map to click to session — runs end to end against real gear, and there are binaries you can download.
One window. A saved session tree down the left, and a terminal, a network crawl, a config capture and a live topology map running at the same time, in the same process, against real gear.
The shell hosts an SSH/telnet/serial terminal, a discovery crawl, a configuration capture, and the map. Each opens in a tab, and any of them can be pulled out into a window of its own without dropping what it is doing. A detached session is a live session: the transport, the read loop and the screen buffer never notice the move.
Discovery takes a seed device, fingerprints the platform, walks CDP/LLDP neighbors breadth-first, and reports every device it reached, failed to reach, or was told about but never dialed — with the credential that worked and how many were tried to get there.
Capture reads configuration and inventory from a device list into a content-addressed store, and keeps the history. A second run of an unchanged estate stores nothing and says so — which is the answer the tool exists to give.
The map is what the crawl was for. Pick a map, and the topology opens with vendor icons, interface-pair labels on every link, and the devices the crawl was told about but never dialed drawn as what they are. It renders in a browser rather than a widget, for the reason the whole product exists: a browser already has a graph engine, a zoom and a print dialog, and none of that is worth rebuilding.
The session tree is the saved inventory, docked down the left with a filter over it: folders of devices, hand-organised, editable in the application or in any text editor, because it is one readable YAML file. Discovery imports into it. Re-import the same estate and only what is new is added — every name, folder and setting already changed by hand is left exactly alone, because a device is matched by its address rather than by whatever the crawler called it.
And the loop closes. Click a node — on the map, in the crawl result table, or in the tree — and a session opens to it, platform already identified, in a tab beside the crawl that found it. That is the thing this project was for.
A fast, single-binary terminal that does the most common things a network engineer needs every day — connect, map, run, capture, find — in one lightweight tool that anybody can have.
Write out the daily commons of network engineering and it gets stark:
- Connect to a device — through jump hosts, with credentials, including gear old enough to need legacy crypto
- See what's actually connected to what
- Run one command across many devices
- Grab a config and see what changed
- Find where a MAC or IP lives
- Identify what an unknown device even is
- Console into the dead one
- Paste configuration without melting the control plane
That is most of the job's mechanical surface. Today it is spread across a session manager, a stale Visio diagram, an automation framework that requires being a programmer, a config-backup server someone has to run, and an NMS nobody opens voluntarily.
The lightweight tool that does the common 80% did not exist — and not because it's hard. Vendors who could build it sell enterprise platforms and have no reason to ship something that undercuts them. Open source solved every piece separately and left the integration as homework. Terminal vendors decided terminals were a finished category twenty years ago. The individual engineer was simply not anybody's buyer. The demand didn't go anywhere; the products did.
The core loop: crawl → map → click → session.
Point the tool at one seed device. It fingerprints the platform, walks CDP/LLDP neighbors breadth-first, and draws the topology. The map is not a report — it is the interface. Click a node and you get a terminal session, with the platform already identified, paging already handled, jump path already known.
That inverts the oldest piece of drudgery in the trade. A session tree is a hand-maintained approximation of the network; discovery ships the real thing and imports into the tree, so what you keep is authored and what you find is merged in rather than overwriting it. The merge is deliberately timid: it adds what it has never seen and touches nothing else.
Around that loop, a genuinely good terminal: serial for the dead box, paced paste for the fragile one, session logging, themes, and the speed of a native Go binary with no runtime, no server, no agent, and nothing to install beyond the app itself.
And because the engine underneath is one abstraction — dial, fingerprint, run, parse, normalize — each additional daily-commons feature is the same machinery pointed at a different question. Configuration capture is the engine asking "what's your config." MAC/IP hunt is the engine asking "who has this address," fanned across the map it already built. The feature list converges instead of sprawling.
This started as a product with a price on it. It isn't one, and the reasoning is worth stating rather than quietly dropping.
Nearly everything load-bearing here is field knowledge, not code: the interface-name normalization table, the per-platform command quirks, the parsing variants that exist only because two real devices described the same link differently. That knowledge took years to collect. Selling access to it puts it behind the smallest possible door — a store listing, one platform, one buyer at a time. Publishing it puts it where the next person who needs it can find it, and lets them send back the variant their gear produced.
GPLv3 specifically, rather than a permissive license, because of what this program touches. It holds credentials and dials production infrastructure, and its most important properties are negative ones: it never writes to a device, it fails closed on a changed host key, it stores no password in the session file. Copyleft means a derivative that quietly relaxes one of those has to publish that it did. Anyone can fork it; nobody can fork it into a closed thing that still looks like this one.
What open source changes about the security stance. Every claim in the section below used to be an assertion you either believed or didn't. They are now checkable — the read-only allowlist is a file you can read, and the test that enforces it is a file you can run. That is a better argument than any paragraph, and it is the main thing the license bought.
Validated against real gear. The SSH core, including legacy algorithms, jump-host chaining and fail-closed host-key verification. Prompt-driven command execution with deterministic output cleaning. Platform fingerprinting by probing. The topology crawler, at scale against an 86-device multi-vendor fabric in a single day. Configuration capture, including the unchanged-run case that proves the content hashing. The terminal, in daily use as its author's primary tool.
Working, and new enough to still be finding things. The shell and its applets. Detachable sessions. The credential vault, OS-keyring backed. The session dialog covering all three transports. The capture store browser. The interactive map, click-to-session from it, and draw.io export of whatever the map is currently showing. The session tree, its YAML file, and the importers that read a crawl's map or another terminal's session file into it.
What is left is the work that makes the pillars feel like one product rather than five good parts: smoothing the workflow between the surfaces, and a credential experience that behaves the same way everywhere it is asked for. Import and export are not yet wired to a button. MAC/IP hunt is still ahead. None of that is small, and none of it is a question of whether the thing works.
Each architecture area has its own document; the index is in internal/README.md. The shell in particular is written up in README_Shell_Arch.md, which is worth reading before extending it — hosting a live widget that can move between windows turned out to have four separate silent failure modes.
Supported platforms: Cisco (IOS / IOS-XE / NX-OS), Arista EOS, Juniper Junos. Those three families cover the overwhelming majority of the enterprise and datacenter installed base, and they are exactly what is built and validated today. A missing platform is a good issue to open, and a parsing variant from gear I don't have is the single most useful thing anybody can send.
Non-goals, stated plainly:
- Not an NMS. No monitoring, no alerting, no server, no agents.
- Not the full breadth of the earlier discovery platform. No SNMP paths, no plugin surface, no viewer ecosystem. There is one viewer, it renders one thing, and the loop is the product.
- Not a config-diff product. Capture stores raw text and content hashes; comparing two captures is a different tool.
A network engineer's forgiveness curve has a cliff exactly where a tool touches credentials and production gear. These are non-negotiable and are built to a standard the rest of the program doesn't need:
- Credential storage done right — OS-backed, no plaintext path.
- Host-key verification that fails closed. A key mismatch is never overridable by convenience, and a trust-on-first-use prompt that nobody answers resolves to no.
- A crawler and capture engine that are provably read-only. Every command either can issue is on an exact-string allowlist, checked twice, and verified against a recording server that reports what actually went on the wire.
- Never hang a device. Per-command timeouts, byte bounds, and a separate smaller concurrency lane for expensive commands.
- The map viewer is the only part that listens on a socket, and it is
treated accordingly. The threat is not the network — the listener is on
loopback — it is that every other page in your browser can also reach
127.0.0.1, and this one will open a session on request. So: a per-run token, anOrigincheck, aHostcheck that stops DNS rebinding, and opaque node identifiers, which mean the only hosts that surface can name are the ones in the map currently open. A click opens a confirmation dialog. It never opens a connection. - The session file is not a secret and is not allowed to become one. It stores a credential reference — a vault entry's name — and never a password or a passphrase, and importing somebody else's exported session file drops any password in it rather than adopting it. The file is readable on purpose; it is worth nothing to whoever reads it.
Everything outside that perimeter ships early and iterates.
If you find something wrong in that list, see SECURITY.md — that is the one class of issue I'd rather hear about privately first.
- Ship early; iterate in the open.
- One engine, many questions. No feature enters unless it is the dial-fingerprint-run-parse loop pointed somewhere new.
- The engine never imports a toolkit. Every package that talks to a device is testable without a display; the Fyne layer is a consumer, never a dependency. It is what lets the same engine serve a CLI, a window, and whatever comes next. The session tree is the clearest case: the file format, the folder rules, the merge and both importers are one package with no toolkit in it, and the panel on the left is a renderer over that.
- The field knowledge is the project. The code is how it is carried. A parsing variant from a device I have never seen is worth more than a feature.
- Nothing writes to a device. Not as a default — as a property of the build.