DevNest documentation

Introduction

DevNest gives developers a single window for all the operational tasks that usually mean jumping between a dozen terminal tabs. Every remote operation runs over a persistent SSH connection — no agent, no cloud relay, nothing leaves your machine.

Guiding principles

• Local-first. The UI and all data live on your machine; nothing reaches third parties.
• No remote agent. Every remote operation is a plain SSH command. If it works over SSH, DevNest can surface it.
• One persistent session per device. A single SSH connection is reused across all panels.
• Atomic context switching. Selecting a device updates every open panel simultaneously.
• Narrow vertical slices. Each release phase ships a working product, not a half-finished skeleton.

Tech stack

Architecture

DevNest is a Tauri app where the Rust backend owns all system access and the React frontend drives the UI. Communication flows exclusively through typed Tauri IPC commands.

┌─────────────────────────────────────────────────────────┐
│  React Frontend (WebView)                               │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐               │
│  │  Panels  │  │  Stores  │  │ Lib/Utils│               │
│  │ (panels) │  │ (store/) │  │  (lib/)  │               │
│  └────┬─────┘  └────┬─────┘  └──────────┘               │
│       │  invoke / listen  (Tauri IPC)                   │
└───────┼─────────────────────────────────────────────────┘
        │
┌───────▼─────────────────────────────────────────────────┐
│  Rust Backend  (src-tauri/src/)                         │
│  commands.rs    →  IPC entrypoint                       │
│  ssh.rs         →  Persistent SSH connection pool       │
│  sftp.rs        →  SFTP file operations                 │
│  terminal.rs    →  PTY over SSH (tmux sessions)         │
│  docker.rs      →  docker CLI over SSH                  │
│  metrics.rs     →  CPU / RAM / net / disk via SSH       │
│  git.rs         →  git operations over SSH              │
│  systemd.rs     →  systemctl over SSH                   │
│  tailscale.rs   →  tailscale CLI over SSH               │
│  ngrok.rs       →  ngrok tunnel management              │
│  http_client.rs →  outbound HTTP from Rust              │
│  sql.rs         →  SSH tunnel → remote DB               │
│  secrets.rs     →  OS keychain storage                  │
│  db.rs          →  local SQLite (device config)         │
└─────────────────────────────────────────────────────────┘

SSH session model

A single SSH connection per device is held in AppState. All panels that need remote access call run_remote_command(device_id, cmd) — they never open their own connections. The terminal panel uses a separate PTY channel (backed by tmux) so interactive sessions are independent of command execution.

Data flow

Secrets (SSH passwords, DB passwords, sudo passwords) are stored in the OS keychain via the keyring crate, never in SQLite plain text. Device metadata lives in a local SQLite database.

Roadmap

Prerequisites

Installation

Run in development

git clone https://github.com/umerghafoor/DevDash
cd DevDash
npm install
npm run tauri dev

Build a release binary

# All platforms
npm run package

# Linux .deb only
npm run package:linux

Adding your first device

1. Click + Add device in the sidebar.
2. Enter a name, hostname or IP, SSH port (default 22), and username.
3. Choose authentication — SSH key (path to private key) or password.
4. Optionally enable Keep alive to auto-connect on startup.
5. Optionally enable Use sudo for commands that require root. You'll be prompted once; the password is stored in the OS keychain.
6. Click Connect — the status indicator turns green when the SSH session is established.

Panels

Each panel below is a self-contained feature surface that operates on the currently selected device.

Terminal

A full PTY terminal powered by xterm.js running over an SSH channel. Each terminal is backed by a tmux session so your shell survives reconnects.

Features

• Multi-tab — multiple shells per device, multiple devices simultaneously
• Persistent sessions — reconnecting reattaches the existing tmux session
• Resize handling — SIGWINCH propagated on window resize
• In-terminal search — Ctrl F opens a search bar (SearchAddon)
• Clickable URLs — WebLinksAddon turns URLs into links
• Completion notification — desktop notification when a long-running command finishes
• Theme-aware — terminal colors inherit the app's active theme

Keyboard shortcuts

Docker

Manages Docker containers on the selected device via docker CLI commands over SSH.

• Container list auto-refreshed every 5 seconds
• Actions — start, stop, restart, remove (with confirmation)
• Container logs — streamed live in-app
• Sudo support — automatically prefixes sudo if enabled for the device

Metrics

Real-time system metrics polled every 2 seconds while the panel is open, paused when hidden.

File browser

A full SFTP file navigator that reuses the existing SSH session — no second connection needed.

• Navigate directories, create folders, rename, delete files and directories
• Upload files from your local machine
• Download files to your local machine
• Open any text file directly in the code editor panel
• Remote file picker for selecting paths in other panels
• Persistent current working directory across panel switches

Code editor

A full Monaco Editor (the engine behind VS Code) for editing remote files in-place. Files are fetched via SFTP, edited locally, and saved back on disk.

• Syntax highlighting for all major languages
• IntelliSense and bracket matching
• JSON and YAML language support via CodeMirror modes
• File size limit — files up to 2 MB are fully loaded
• Save shortcut — Ctrl S / Cmd S

Git & Git graph

Run Git operations on a remote repository over SSH without needing to open a terminal.

• View working tree status — staged, unstaged, untracked
• Diff view for changed files
• Stage, unstage, and commit changes
• Push and pull
• Branch list and switching
• Git graph — visual commit history graph (separate panel)

Log viewer

Tail and search log files in real time, including structured sources like journalctl and Docker logs.

Sources

• Arbitrary file paths via tail -F <path>
• Systemd journal — journalctl -u <unit> -f
• Docker container logs — docker logs -f <container>

Features

• Live streaming with pause / resume
• Search and filter by keyword
• Line highlighting rules
• Jump to bottom, copy individual lines

Systemd & services

Manage system services on systemd-based systems. The Services panel lists every service with quick start, stop, restart, enable and disable controls. The Systemd panel offers a more detailed unit-aware view with inline journal output.

Cron manager

Read and write the user's crontab via a form-based editor — no need to remember cron syntax.

• Reads existing crontab with crontab -l
• Form editor with fields for minute, hour, day, month, weekday, and command
• Cron expression validation
• Human-readable description of each schedule
• Writes back with crontab -

Ports & processes

The Ports panel shows all listening TCP/UDP ports on the device (via ss -tlnp) alongside the process that owns each socket. The Processes panel lists running processes sorted by CPU or memory (via ps aux), each with a kill button and signal selector (SIGTERM, SIGKILL, …).

Tailscale

Control the Tailscale mesh network directly from DevNest.

• Runs tailscale status --json to list all mesh peers
• Shows IP, hostname, and online state per peer
• Enable or disable exit nodes via tailscale set --exit-node=...
• One-click SSH to this peer — pre-fills the device manager form

Ngrok

Manage ngrok tunnels running on the selected device. View active tunnels, their public URLs, and the local addresses they forward to.

HTTP client

A built-in REST client — similar to Insomnia or Postman — for testing APIs from within DevNest.

• Multi-tab request history
• All HTTP methods — GET, POST, PUT, PATCH, DELETE, …
• Custom headers and request body
• JSON response syntax highlighting
• Persistent request history (Zustand store)

SQL client

Connect to a remote database through an SSH tunnel — the tunnel is opened automatically, no manual port forwarding needed.

Supported databases

• MySQL / MariaDB
• PostgreSQL
• SQLite (file path on remote)

Features

• SSH tunnel created per connection, torn down on disconnect
• Database password stored in OS keychain
• Multi-tab query editor
• Result table with column sorting

Markdown

A split-pane Markdown editor with live HTML preview powered by marked. Write documentation, notes, or README files and see the rendered output in real time.

Project structure

DevDash/
├── src/                       # React frontend
│   ├── app/                   # App root (App.tsx, device heartbeat)
│   ├── components/            # Shared UI components
│   │   ├── AddDeviceDialog.tsx
│   │   ├── CodeEditor.tsx
│   │   ├── CommandPalette.tsx
│   │   ├── MainPanel.tsx
│   │   ├── Sidebar.tsx
│   │   ├── StatusBar.tsx
│   │   └── ...
│   ├── panels/                # Feature panels (one file per panel)
│   │   ├── DockerPanel.tsx
│   │   ├── TerminalPanel.tsx
│   │   ├── MetricsPanel.tsx
│   │   └── ...               # 19 panels total
│   ├── store/                 # Zustand global stores
│   │   ├── app-store.ts       # Devices, active device, tabs
│   │   ├── theme-store.ts     # Color theme
│   │   ├── http-store.ts      # HTTP client history
│   │   └── ...
│   └── lib/                   # Frontend utilities
│       ├── api.ts             # Typed wrappers over Tauri invoke()
│       ├── fuzzy.ts           # Fuzzy search (Command Palette)
│       └── ...
├── src-tauri/                 # Tauri + Rust backend
│   └── src/
│       ├── commands.rs        # All tauri::command handlers
│       ├── ssh.rs             # SSH connection pool
│       ├── sftp.rs            # SFTP operations
│       ├── terminal.rs        # PTY / tmux management
│       ├── docker.rs          # Docker CLI parsing
│       ├── metrics.rs         # System metrics parsing
│       └── ...
├── docs/
│   └── plans/                 # High-level plan + low-level TODO
└── public/                    # Static assets

Commands

Rust backend

# Format
cargo fmt --check --manifest-path src-tauri/Cargo.toml

# Lint
cargo clippy --all-targets -- -D warnings

# Test
cargo test --manifest-path src-tauri/Cargo.toml

Adding a new Tauri command

1. Add the implementation in the relevant module (e.g. docker.rs).
2. Expose it as a public function in commands.rs annotated with #[tauri::command].
3. Register it in the .invoke_handler() call in lib.rs.
4. Add a typed wrapper in src/lib/api.ts using invoke().

React frontend

Adding a new panel

1. Create src/panels/YourPanel.tsx with a Props interface accepting deviceId: string.
2. Register the panel in MainPanel.tsx — add it to the panel registry and sidebar tab list.
3. Add any necessary Zustand store state in the appropriate store file.

State management

Testing

Tests live in src/store/app-store.test.ts and src/test/setup.ts. The framework is Vitest with @testing-library/react.

npm test            # single run
npm run test:watch  # watch mode

Releases & CI

Every push to main triggers the CI pipeline, which:

1. Runs lint, typecheck, and all tests
2. Builds release binaries for Linux (.deb, .rpm, .AppImage), macOS, and Windows
3. Publishes a GitHub release with all installable artifacts

Current version — v1.1.0.