navoro

README

A multi-engine database explorer with a React UI, running either as its own standalone desktop app (Wails3) or embedded inside condui as a private git submodule at ssh-gui/backend/dbexplorer.

Modes

• Standalone — its own Wails3 desktop app, own encrypted connection vault, own SSH tunnel handling. Runs independently of condui.
• Embedded in condui — opened as a satellite window from an existing condui SSH session. Connections are proxied through that session's tunnel instead of navoro's own vault; the UI is served from the same local HTTP port, with session/type/port/path injected into the page at render time.

Both modes share the same backend (core/) and the same React frontend (core/frontend/) — the UI detects which mode it's in and adjusts (e.g. hides the connection vault when embedded).

Supported database engines

Relational (SQL)

Engine	SSH tunnel	Notes
PostgreSQL	✅	also covers TimescaleDB and CockroachDB (Postgres wire protocol)
MySQL / MariaDB	✅
SQL Server / Azure SQL	✅
SQLite	—	local file, synced over SFTP when the file lives on a remote host
Oracle	—	connects by service name; go-ora has no dialer hook
ClickHouse	✅
Snowflake	—	cloud/HTTPS only
Firebird	—	connects by database file path; no dialer hook
QuestDB	✅	rides the PostgreSQL driver (Postgres wire protocol)
InfluxDB 3.x	✅	real SQL over HTTP (Apache DataFusion)

Query-language-agnostic (non-SQL text queries)

Engine	SSH tunnel	Query language
Cassandra	✅	CQL
Neo4j	—	Cypher, with a live graph visualization (see below)
InfluxDB 2.x	✅	Flux

Key-value / document

Engine	SSH tunnel	Notes
Redis	✅	per-DB-index browsing, type-aware value display (string/list/hash/set/zset)
Elasticsearch	✅	indices as "databases", documents as keys
MongoDB	✅	compound collection/docId keys, full document JSON editing

Every engine is a self-contained adapter behind a Driver (relational/text-query) or KVDriver (key-value) interface (core/driver.go, core/kvdriver.go) — adding a new engine is one new file plus one init() registration, with no changes needed anywhere else in the backend.

Features

• Schema browsing — connection → database → (schema, when the engine has one worth showing) → table tree, with real introspection: columns, indexes, and foreign keys pulled from each engine's own system catalogs/data dictionary (information_schema, pg_catalog, all_* Oracle views, rdb$* Firebird system tables, system_schema Cassandra, etc.), not placeholders.
• Query editor — multi-tab SQL/CQL/Cypher/Flux editor (CodeMirror 6: syntax highlighting + schema-aware autocomplete) with a results grid, execution timing, and an error panel.
• Editable results grid — opening a table from the tree lets you edit cells, add, and delete rows inline (generates the UPDATE/INSERT/DELETE for you), as long as the table has a detected primary key.
• Export / import — export any result set as CSV or JSON; import a CSV file into an existing table with column mapping and a preview.
• Full-schema ER diagram — every table in the active database as a draggable node-link diagram connected by its foreign keys (in addition to the per-table mini-ER in the Details panel).
• Backup / Restore — logical .sql dump (best-effort CREATE TABLE + INSERT) and restore, portable across connection modes since it runs through the same query engine as everything else.
• Structure sync — compare a database's tables/columns against another saved connection and generate an ALTER/CREATE script to bring the target in line.
• Graph visualization for Neo4j — query results that carry nodes/relationships (including inside collect(), paths, or nested maps) render as an interactive node-link graph alongside the flattened table: drag nodes, pan, zoom, click a node to inspect its full properties. Falls back to the plain results table for everything else.
• Key-value browser — for Redis/Elasticsearch/MongoDB, a dedicated key list + value panel replaces the relational tree, with type/TTL display and inline value editing.
• SSH tunneling — any engine with a dialer hook in its Go driver (see table above) can be reached through an SSH tunnel, sharing the same tunnel abstraction (core.DialFunc/ConnParams.Dial) across every engine — password or private-key SSH auth.
• Encrypted connection vault (standalone mode) — connections are stored locally, encrypted with Argon2id + AES-256-GCM under a master password (vault/crypto.go, vault/store.go); nothing is stored in plaintext.
• Light/dark theme — navoro brand palette (core/frontend/src/theme.css), togglable and persisted.
• SQLite over SFTP — when a SQLite database lives on the remote host of a condui SSH session, navoro syncs the file locally, runs queries against the local copy, and syncs writes back.

See docs/roadmap.md for the feature roadmap and scope notes on what's implemented vs. planned.

Architecture

core/           connection manager, per-engine drivers, HTML/asset embedding
  driver.go       Driver interface + registry (relational / text-query engines)
  kvdriver.go     KVDriver interface + registry (key-value engines)
  manager.go      Manager: connection lifecycle, NormalizeDbType (alias → driver name)
  <engine>.go     one file per engine, self-registering via init()
  frontend/       React + Vite UI (embedded into the Go binary via go:embed for release builds)
vault/          standalone-mode encrypted connection store
sshtunnel/      SSH tunnel dialing, shared by every tunnel-capable driver
app*.go         standalone Wails3 app: vault, connections, queries
httpserver.go   local HTTP server backing both the standalone window and condui's satellite window
main.go         Wails3 entrypoint (standalone mode)

Building

Standalone:

cd core/frontend && npm install && npm run build   # produces core/frontend/dist, embedded via go:embed
cd ../.. && go build .                              # or: task build
wails3 dev                                          # dev mode with Vite hot reload

Embedded in condui (from the ssh-gui module, as a submodule):

go work init . ./backend/dbexplorer   # link the submodule for the tagged build
go build -tags dbmanager .

condui's default (open-source) build excludes navoro entirely — go build . without the dbmanager tag compiles against a stub that reports the feature as unavailable, so the private submodule is never required to build the OSS product.

Brand

• Icon — the isotype: a stroke "N" with three teal dots stacked to its right, inside a navy circle (docs/brand/navoro-icon.svg).
• Monochrome — the same mark in solid white with no circle, for placement on surfaces that aren't the app's own navy (docs/brand/navoro-icon-mono.svg).
• Lockup — icon + wordmark, used in the sidebar (core/frontend/src/components/Logo.jsx) and above.
• Palette — marino profundo #12233F, marino medio #1B3563, turquesa #1BA89C, turquesa claro #4FC7BC, turquesa oscuro #0E766D, plus the neutral/functional scale defined in core/frontend/src/theme.css.
• Type — Poppins (brand/titles, 500/600/700), Inter (UI text), JetBrains Mono (data/code).

Full brand manual: Design navoro.pdf.

Status

The standalone desktop app (this repo) is released independently — see Releasing for how tagged builds ship for Windows, macOS and Linux with an in-app updater. It's also still embedded inside condui as a submodule, sharing the same core/ backend and React frontend in both modes.

License

navoro is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) — see LICENSE.

Commercial licensing may be available separately.

Trademark

The navoro name, logo and visual identity are not included under the software license.